@microsoft/inshellisense 0.0.1-rc.5 → 0.0.1-rc.7

package/README.md

@@ -2,7 +2,7 @@
 
 `inshellisense` provides IDE style autocomplete for shells. It's a terminal native runtime for [autocomplete](https://github.com/withfig/autocomplete) which has support for 600+ command line tools. `inshellisense` supports Windows, Linux, & macOS.
 
-<p align="center"><img alt="demo of inshellisense working" src="/docs/demo.gif" height="450px"/></p>
+<p align="center"><img alt="demo of inshellisense working" src="/docs/demo.gif"/></p>
 
 ## Getting Started
 
@@ -21,6 +21,25 @@ npm install -g @microsoft/inshellisense
 
 After completing the installation, you can run `is` to start the autocomplete session for your desired shell. Additionally, inshellisense is also aliased under `inshellisense` after installation.
 
+### Usage
+
+| Action                                | Command |
+| ------------------------------------- | ------- |
+| Start                                 | `is`    |
+| Stop                                  | `exit`  |
+| Check If Inside Inshellisense Session | `is -c` |
+
+#### Keybindings
+
+All other keys are passed through to the shell. The keybindings below are only captured when the inshellisense suggestions are visible, otherwise they are passed through to the shell as well.
+
+| Action                    | Keybinding     |
+| ------------------------- | -------------- |
+| Accept Current Suggestion | <kbd>tab</kbd> |
+| View Next Suggestion      | <kbd>↓</kbd>   |
+| View Previous Suggestion  | <kbd>↑</kbd>   |
+| Dismiss Suggestions       | <kbd>esc</kbd> |
+
 ## Integrations
 
 inshellisense supports the following shells:
@@ -30,6 +49,7 @@ inshellisense supports the following shells:
 - [fish](https://github.com/fish-shell/fish-shell)
 - [pwsh](https://github.com/PowerShell/PowerShell)
 - [powershell](https://learn.microsoft.com/en-us/powershell/scripting/windows-powershell/starting-windows-powershell) (Windows Powershell)
+- [cmd](https://learn.microsoft.com/en-us/windows-server/administration/windows-commands/cmd) _(experimental)_
 
 ## Contributing
 

package/build/commands/complete.js

@@ -0,0 +1,15 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import os from "node:os";
+import { Command } from "commander";
+import { getSuggestions } from "../runtime/runtime.js";
+import { Shell } from "../utils/shell.js";
+const action = async (input) => {
+    const suggestions = await getSuggestions(input, process.cwd(), os.platform() === "win32" ? Shell.Cmd : Shell.Bash);
+    process.stdout.write(JSON.stringify(suggestions));
+};
+const cmd = new Command("complete");
+cmd.description(`generates a completion for the provided input`);
+cmd.argument("<input>");
+cmd.action(action);
+export default cmd;

package/build/commands/root.js

@@ -1,11 +1,19 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
-import { render } from "../ui/ui-root.js";
-import { Shell, supportedShells as shells, setupZshDotfiles } from "../utils/shell.js";
+import { render, renderConfirmation } from "../ui/ui-root.js";
+import { Shell, supportedShells as shells, setupZshDotfiles, setupBashPreExec } from "../utils/shell.js";
 import { inferShell } from "../utils/shell.js";
 import { loadConfig } from "../utils/config.js";
+import log from "../utils/log.js";
 export const supportedShells = shells.join(", ");
 export const action = (program) => async (options) => {
+    const inISTerm = process.env.ISTERM === "1";
+    if (options.check || inISTerm) {
+        process.stdout.write(renderConfirmation(inISTerm));
+        return;
+    }
+    if (options.verbose)
+        await log.enable();
     await loadConfig(program);
     const shell = options.shell ?? (await inferShell());
     if (shell == null) {
@@ -17,5 +25,8 @@ export const action = (program) => async (options) => {
     if (shell == Shell.Zsh) {
         await setupZshDotfiles();
     }
+    else if (shell == Shell.Bash) {
+        await setupBashPreExec();
+    }
     await render(shell);
 };

package/build/index.js

@@ -3,6 +3,7 @@
 // Licensed under the MIT License.
 /* eslint-disable header/header */
 import { Command } from "commander";
+import complete from "./commands/complete.js";
 import uninstall from "./commands/uninstall.js";
 import { action, supportedShells } from "./commands/root.js";
 import { getVersion } from "./utils/version.js";
@@ -13,6 +14,9 @@ program
     .version(await getVersion(), "-v, --version", "output the current version")
     .action(action(program))
     .option("-s, --shell <shell>", `shell to use for command execution, supported shells: ${supportedShells}`)
+    .option("-c, --check", `check if shell is in an inshellisense session`)
+    .option("-V, --verbose", `enable verbose logging`)
     .showHelpAfterError("(add --help for additional information)");
+program.addCommand(complete);
 program.addCommand(uninstall);
 program.parse();

package/build/isterm/commandManager.js

@@ -26,6 +26,9 @@ export class CommandManager {
         }
     }
     handlePromptStart() {
+        if (this.#activeCommand.promptStartMarker?.line == -1) {
+            this.#previousCommandLines = new Set();
+        }
         this.#activeCommand = { promptStartMarker: this.#terminal.registerMarker(0), hasOutput: false, cursorTerminated: false };
     }
     handlePromptEnd() {
@@ -170,11 +173,13 @@ export class CommandManager {
                     const cell = line?.getCell(i);
                     if (cell == null)
                         continue;
+                    const chars = cell.getChars();
+                    const cleanedChars = chars == "" ? " " : chars;
                     if (!this._isSuggestion(cell) && suggestions.length == 0) {
-                        command += cell.getChars();
+                        command += cleanedChars;
                     }
                     else {
-                        suggestions += cell.getChars();
+                        suggestions += cleanedChars;
                     }
                 }
                 lineY += 1;

package/build/isterm/pty.js

@@ -24,10 +24,12 @@ export class ISTerm {
     onData;
     onExit;
     shellBuffer;
+    cwd = "";
     #pty;
     #ptyEmitter;
     #term;
     #commandManager;
+    #shell;
     constructor({ shell, cols, rows, env, shellTarget, shellArgs }) {
         this.#pty = pty.spawn(shellTarget, shellArgs ?? [], {
             name: "xterm-256color",
@@ -43,6 +45,7 @@ export class ISTerm {
         this.#term = new xterm.Terminal({ allowProposedApi: true, rows, cols });
         this.#term.parser.registerOscHandler(IsTermOscPs, (data) => this._handleIsSequence(data));
         this.#commandManager = new CommandManager(this.#term, shell);
+        this.#shell = shell;
         this.#ptyEmitter = new EventEmitter();
         this.#pty.onData((data) => {
             this.#term.write(data, () => {
@@ -59,6 +62,23 @@ export class ISTerm {
         };
         this.onExit = this.#pty.onExit;
     }
+    _deserializeIsMessage(message) {
+        return message.replaceAll(/\\(\\|x([0-9a-f]{2}))/gi, (_match, op, hex) => (hex ? String.fromCharCode(parseInt(hex, 16)) : op));
+    }
+    _sanitizedCwd(cwd) {
+        if (cwd.match(/^['"].*['"]$/)) {
+            cwd = cwd.substring(1, cwd.length - 1);
+        }
+        // Convert a drive prefix to windows style when using Git Bash
+        if (os.platform() === "win32" && this.#shell == Shell.Bash && cwd && cwd.match(/^\/[A-z]{1}\//)) {
+            cwd = `${cwd[1]}:\\` + cwd.substring(3, cwd.length);
+        }
+        // Make the drive letter uppercase on Windows (see vscode #9448)
+        if (os.platform() === "win32" && cwd && cwd[1] === ":") {
+            return cwd[0].toUpperCase() + cwd.substring(1);
+        }
+        return cwd;
+    }
     _handleIsSequence(data) {
         const argsIndex = data.indexOf(";");
         const sequence = argsIndex === -1 ? data : data.substring(0, argsIndex);
@@ -69,6 +89,13 @@ export class ISTerm {
             case IstermOscPt.PromptEnded:
                 this.#commandManager.handlePromptEnd();
                 break;
+            case IstermOscPt.CurrentWorkingDirectory: {
+                const cwd = data.split(";").at(1);
+                if (cwd != null) {
+                    this.cwd = path.resolve(this._sanitizedCwd(this._deserializeIsMessage(cwd)));
+                }
+                break;
+            }
             default:
                 return false;
         }
@@ -204,14 +231,18 @@ const convertToPtyTarget = async (shell) => {
     return { shellTarget, shellArgs };
 };
 const convertToPtyEnv = (shell) => {
+    const env = {
+        ...process.env,
+        ISTERM: "1",
+    };
     switch (shell) {
         case Shell.Cmd: {
             const prompt = process.env.PROMPT ? process.env.PROMPT : "$P$G";
-            return { ...process.env, PROMPT: `${IstermPromptStart}${prompt}${IstermPromptEnd}` };
+            return { ...env, PROMPT: `${IstermPromptStart}${prompt}${IstermPromptEnd}` };
         }
         case Shell.Zsh: {
-            return { ...process.env, ZDOTDIR: zdotdir, USER_ZDOTDIR: userZdotdir };
+            return { ...env, ZDOTDIR: zdotdir, USER_ZDOTDIR: userZdotdir };
         }
     }
-    return process.env;
+    return env;
 };

package/build/runtime/generator.js

@@ -1,11 +1,12 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
+import log from "../utils/log.js";
 import { runTemplates } from "./template.js";
 import { buildExecuteShellCommand } from "./utils.js";
-const getGeneratorContext = () => {
+const getGeneratorContext = (cwd) => {
     return {
         environmentVariables: Object.fromEntries(Object.entries(process.env).filter((entry) => entry[1] != null)),
-        currentWorkingDirectory: process.cwd(),
+        currentWorkingDirectory: cwd,
         currentProcess: "",
         sshPrefix: "",
         isDangerous: false,
@@ -13,30 +14,40 @@ const getGeneratorContext = () => {
     };
 };
 // TODO: add support for caching, trigger, & getQueryTerm
-export const runGenerator = async (generator, tokens) => {
-    const { script, postProcess, scriptTimeout, splitOn, custom, template } = generator;
+export const runGenerator = async (generator, tokens, cwd) => {
+    // TODO: support trigger
+    const { script, postProcess, scriptTimeout, splitOn, custom, template, filterTemplateSuggestions } = generator;
     const executeShellCommand = buildExecuteShellCommand(scriptTimeout ?? 5000);
     const suggestions = [];
     try {
         if (script) {
-            const scriptOutput = typeof script === "function" ? script(tokens) : script != null ? await executeShellCommand(script) : "";
+            const shellInput = typeof script === "function" ? script(tokens) : script;
+            const scriptOutput = Array.isArray(shellInput)
+                ? await executeShellCommand({ command: shellInput.at(0) ?? "", args: shellInput.slice(1) })
+                : await executeShellCommand(shellInput);
             if (postProcess) {
-                suggestions.push(...postProcess(scriptOutput, tokens));
+                suggestions.push(...postProcess(scriptOutput.stdout, tokens));
             }
             else if (splitOn) {
-                suggestions.push(...scriptOutput.split(splitOn).map((s) => ({ name: s })));
+                suggestions.push(...scriptOutput.stdout.split(splitOn).map((s) => ({ name: s })));
             }
         }
         if (custom) {
-            suggestions.push(...(await custom(tokens, executeShellCommand, getGeneratorContext())));
+            suggestions.push(...(await custom(tokens, executeShellCommand, getGeneratorContext(cwd))));
         }
         if (template != null) {
-            suggestions.push(...(await runTemplates(template)));
+            const templateSuggestions = await runTemplates(template, cwd);
+            if (filterTemplateSuggestions) {
+                suggestions.push(...filterTemplateSuggestions(templateSuggestions));
+            }
+            else {
+                suggestions.push(...templateSuggestions);
+            }
         }
         return suggestions;
     }
     catch (e) {
-        /* empty */
+        log.debug({ msg: "generator failed", e, script, splitOn, template });
     }
     return suggestions;
 };

package/build/runtime/parser.js

@@ -1,6 +1,6 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
-const cmdDelim = /(\|\|)|(&&)|(;)/;
+const cmdDelim = /(\|\|)|(&&)|(;)|(\|)/;
 const spaceRegex = /\s/;
 export const parseCommand = (command) => {
     const lastCommand = command.split(cmdDelim).at(-1)?.trimStart();
@@ -56,7 +56,7 @@ const lex = (command) => {
         tokens.push({
             token: command.slice(readingIdx),
             complete: false,
-            isOption: false,
+            isOption: readingFlag,
         });
     }
     return tokens;

package/build/runtime/runtime.js

@@ -4,9 +4,10 @@ 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";
 // eslint-disable-next-line @typescript-eslint/no-explicit-any -- recursive type, setting as any
 const specSet = {};
 speclist.forEach((s) => {
@@ -46,7 +47,7 @@ const lazyLoadSpec = async (key) => {
 const lazyLoadSpecLocation = async (location) => {
     return; //TODO: implement spec location loading
 };
-export const getSuggestions = async (cmd) => {
+export const getSuggestions = async (cmd, cwd, shell) => {
     const activeCmd = parseCommand(cmd);
     const rootToken = activeCmd.at(0);
     if (activeCmd.length === 0 || !rootToken?.complete) {
@@ -58,11 +59,19 @@ export const getSuggestions = async (cmd) => {
     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);
     if (result == null)
         return;
-    const lastCommand = activeCmd.at(-1);
-    const charactersToDrop = lastCommand?.complete ? 0 : lastCommand?.token.length ?? 0;
+    let charactersToDrop = lastCommand?.complete ? 0 : lastCommand?.token.length ?? 0;
+    if (pathy) {
+        charactersToDrop = pathyComplete ? 0 : path.basename(lastCommand?.token ?? "").length;
+    }
     return { ...result, charactersToDrop };
 };
 const getPersistentOptions = (persistentOptions, options) => {
@@ -142,7 +151,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, persistentOptions, acceptedTokens) => {
     if (tokens.length === 0) {
         throw new Error("invalid state reached, option expected but no tokens found");
     }
@@ -150,37 +159,37 @@ 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, persistentOptions, acceptedTokens.concat(activeToken), true, false);
     }
-    return runSubcommand(tokens.slice(1), subcommand, persistentOptions, acceptedTokens.concat({ ...activeToken, isPersistent }));
+    return runSubcommand(tokens.slice(1), subcommand, cwd, persistentOptions, acceptedTokens.concat({ ...activeToken, isPersistent }));
 };
-const runArg = async (tokens, args, subcommand, persistentOptions, acceptedTokens, fromOption, fromVariadic) => {
+const runArg = async (tokens, args, subcommand, cwd, persistentOptions, acceptedTokens, fromOption, fromVariadic) => {
     if (args.length === 0) {
-        return runSubcommand(tokens, subcommand, persistentOptions, acceptedTokens, true, !fromOption);
+        return runSubcommand(tokens, subcommand, cwd, 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);
     }
     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);
     }
     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, 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, 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, persistentOptions, acceptedTokens.concat(activeToken), fromOption, true);
     }
     else if (activeArg.isCommand) {
         if (tokens.length <= 0) {
@@ -192,16 +201,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);
     }
-    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, persistentOptions, acceptedTokens.concat(activeToken), fromOption, false);
 };
-const runSubcommand = async (tokens, subcommand, persistentOptions = [], acceptedTokens = [], argsDepleted = false, argsUsed = false) => {
+const runSubcommand = async (tokens, subcommand, cwd, 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);
     }
     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);
     }
     const activeToken = tokens[0];
     const activeArgsLength = subcommand.args instanceof Array ? subcommand.args.length : 1;
@@ -209,16 +218,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, 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, 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, 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, persistentOptions, acceptedTokens.concat(activeToken));
 };

package/build/runtime/suggestion.js

@@ -1,5 +1,6 @@
 // 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;
@@ -116,14 +117,14 @@ function filter(suggestions, filterStrategy, partialCmd, suggestionType) {
                 .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();
+    const suggestions = (await Promise.all(generators.map((gen) => runGenerator(gen, tokens, cwd)))).flat();
     return filter(suggestions, 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 +138,32 @@ 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) => {
+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) => {
     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 +173,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(suggestions.sort((a, b) => b.priority - a.priority), acceptedTokens))),
     };
 };
-export const getArgDrivenRecommendation = async (args, subcommand, persistentOptions, partialCmd, acceptedTokens, variadicArgBound) => {
+export const getArgDrivenRecommendation = async (args, subcommand, persistentOptions, partialToken, acceptedTokens, variadicArgBound, cwd) => {
+    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(suggestions.sort((a, b) => b.priority - a.priority), acceptedTokens))),
         argumentDescription: activeArg.description ?? activeArg.name,
     };
 };

package/build/runtime/template.js

@@ -1,14 +1,14 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 import fsAsync from "node: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 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: 90, context: { templateType: "filepaths" } }));
 };
-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: 90, context: { templateType: "folders" } }));
 };
 // TODO: implement history template
 const historyTemplate = () => {
@@ -18,18 +18,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();
 };