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

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();
 };

package/build/runtime/utils.js

@@ -1,22 +1,121 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
-import { exec, spawn } from "node:child_process";
-export const buildExecuteShellCommand = (timeout) => 
-// eslint-disable-next-line @typescript-eslint/no-unused-vars -- TODO: use cwd in the future
-async (command, cwd) => {
-    return new Promise((resolve) => {
-        exec(command, { timeout }, (_, stdout, stderr) => {
-            resolve(stdout || stderr);
-        });
-    });
+import path from "node:path";
+import { spawn } from "node:child_process";
+import fsAsync from "node:fs/promises";
+import { getPathSeparator, gitBashPath, Shell } from "../utils/shell.js";
+import log from "../utils/log.js";
+const getExecutionShell = async () => {
+    if (process.platform !== "win32")
+        return;
+    try {
+        return await gitBashPath();
+    }
+    catch (e) {
+        log.debug({ msg: "failed to load posix shell for windows child_process.spawn, some generators might fail", error: e });
+    }
+};
+const bashSpecialCharacters = /[&|<>\s]/g;
+// escape whitespace & special characters in an argument when not quoted
+const shouldEscapeArg = (arg) => {
+    const hasSpecialCharacter = bashSpecialCharacters.test(arg);
+    const isSingleCharacter = arg.length === 1;
+    return hasSpecialCharacter && !isSingleCharacter && !isQuoted(arg, `"`);
+};
+/* based on libuv process.c used by nodejs, only quotes are escaped for shells. if using git bash need to escape whitespace & special characters in an argument */
+const escapeArgs = (shell, args) => {
+    // only escape args for git bash
+    if (process.platform !== "win32" || shell == undefined)
+        return args;
+    return args.map((arg) => (shouldEscapeArg(arg) ? `"${arg.replaceAll('"', '\\"')}"` : arg));
 };
-export const executeShellCommandTTY = async (shell, command) => {
-    const child = spawn(shell, ["-c", command.trim()], { stdio: "inherit" });
+const isQuoted = (value, quoteChar) => (value?.startsWith(quoteChar) && value?.endsWith(quoteChar)) ?? false;
+const quoteString = (value, quoteChar) => {
+    if (isQuoted(value, quoteChar))
+        return value;
+    const escapedValue = value.replaceAll(`\\${quoteChar}`, quoteChar).replaceAll(quoteChar, `\\${quoteChar}`);
+    return `${quoteChar}${escapedValue}${quoteChar}`;
+};
+const needsQuoted = (value, quoteChar) => isQuoted(value, quoteChar) || value.includes(" ");
+const getShellQuoteChar = (shell) => {
+    switch (shell) {
+        case Shell.Zsh:
+        case Shell.Bash:
+        case Shell.Fish:
+            return `"`;
+        case Shell.Xonsh:
+            return `'`;
+        case Shell.Nushell:
+            return "`";
+        case Shell.Pwsh:
+        case Shell.Powershell:
+            return `'`;
+        case Shell.Cmd:
+            return `"`;
+    }
+};
+export const getShellWhitespaceEscapeChar = (shell) => {
+    switch (shell) {
+        case Shell.Zsh:
+        case Shell.Bash:
+        case Shell.Fish:
+        case Shell.Xonsh:
+        case Shell.Nushell:
+            return "\\";
+        case Shell.Pwsh:
+        case Shell.Powershell:
+            return "`";
+        case Shell.Cmd:
+            return "^";
+    }
+};
+export const escapePath = (value, shell) => value != null && needsQuoted(value, getShellQuoteChar(shell)) ? quoteString(value, getShellQuoteChar(shell)) : value;
+export const buildExecuteShellCommand = async (timeout) => async ({ command, env, args, cwd }) => {
+    const executionShell = await getExecutionShell();
+    const escapedArgs = escapeArgs(executionShell, args);
+    const child = spawn(command, escapedArgs, { cwd, env: { ...process.env, ...env, ISTERM: "1" }, shell: executionShell });
+    setTimeout(() => child.kill("SIGKILL"), timeout);
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (data) => (stdout += data));
+    child.stderr.on("data", (data) => (stderr += data));
+    child.on("error", (err) => {
+        log.debug({ msg: "shell command failed", command, args, e: err.message });
+    });
     return new Promise((resolve) => {
         child.on("close", (code) => {
             resolve({
-                code,
+                status: code ?? 0,
+                stderr,
+                stdout,
             });
         });
     });
 };
+export const resolveCwd = async (cmdToken, cwd, shell) => {
+    if (cmdToken == null)
+        return { cwd, pathy: false, complete: false };
+    const { token: rawToken, isQuoted } = cmdToken;
+    const escapedToken = !isQuoted ? rawToken.replaceAll(" ", "\\ ") : rawToken;
+    const token = escapedToken;
+    const sep = getPathSeparator(shell);
+    if (!token.includes(sep))
+        return { cwd, pathy: false, complete: false };
+    const resolvedCwd = path.isAbsolute(token) ? token : path.join(cwd, token);
+    try {
+        await fsAsync.access(resolvedCwd, fsAsync.constants.R_OK);
+        return { cwd: resolvedCwd, pathy: true, complete: token.endsWith(sep) };
+    }
+    catch {
+        // fallback to the parent folder if possible
+        const baselessCwd = resolvedCwd.substring(0, resolvedCwd.length - path.basename(resolvedCwd).length);
+        try {
+            await fsAsync.access(baselessCwd, fsAsync.constants.R_OK);
+            return { cwd: baselessCwd, pathy: true, complete: token.endsWith(sep) };
+        }
+        catch {
+            /*empty*/
+        }
+        return { cwd, pathy: false, complete: false };
+    }
+};

package/build/ui/suggestionManager.js

@@ -0,0 +1,162 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import { getSuggestions } from "../runtime/runtime.js";
+import { renderBox, truncateText, truncateMultilineText } from "./utils.js";
+import ansi from "ansi-escapes";
+import chalk from "chalk";
+import log from "../utils/log.js";
+import { getConfig } from "../utils/config.js";
+const maxSuggestions = 5;
+const suggestionWidth = 40;
+const descriptionWidth = 30;
+const descriptionHeight = 5;
+const borderWidth = 2;
+const activeSuggestionBackgroundColor = "#7D56F4";
+export const MAX_LINES = borderWidth + Math.max(maxSuggestions, descriptionHeight);
+export class SuggestionManager {
+    #term;
+    #command;
+    #activeSuggestionIdx;
+    #suggestBlob;
+    #shell;
+    #hideSuggestions = false;
+    constructor(terminal, shell) {
+        this.#term = terminal;
+        this.#suggestBlob = { suggestions: [] };
+        this.#command = "";
+        this.#activeSuggestionIdx = 0;
+        this.#shell = shell;
+    }
+    async _loadSuggestions() {
+        const commandText = this.#term.getCommandState().commandText;
+        if (!commandText || this.#hideSuggestions) {
+            this.#suggestBlob = undefined;
+            this.#activeSuggestionIdx = 0;
+            return;
+        }
+        if (commandText == this.#command) {
+            return;
+        }
+        this.#command = commandText;
+        const suggestionBlob = await getSuggestions(commandText, this.#term.cwd, this.#shell);
+        this.#suggestBlob = suggestionBlob;
+        this.#activeSuggestionIdx = 0;
+    }
+    _renderArgumentDescription(description, x) {
+        if (!description)
+            return "";
+        return renderBox([truncateText(description, descriptionWidth - borderWidth)], descriptionWidth, x);
+    }
+    _renderDescription(description, x) {
+        if (!description)
+            return "";
+        return renderBox(truncateMultilineText(description, descriptionWidth - borderWidth, descriptionHeight), descriptionWidth, x);
+    }
+    _descriptionRows(description) {
+        if (!description)
+            return 0;
+        return truncateMultilineText(description, descriptionWidth - borderWidth, descriptionHeight).length;
+    }
+    _renderSuggestions(suggestions, activeSuggestionIdx, x) {
+        return renderBox(suggestions.map((suggestion, idx) => {
+            const suggestionText = `${suggestion.icon} ${suggestion.name}`;
+            const truncatedSuggestion = truncateText(suggestionText, suggestionWidth - 2);
+            return idx == activeSuggestionIdx ? chalk.bgHex(activeSuggestionBackgroundColor)(truncatedSuggestion) : truncatedSuggestion;
+        }), suggestionWidth, x);
+    }
+    validate(suggestion) {
+        const commandText = this.#term.getCommandState().commandText;
+        return !commandText ? { data: "", rows: 0 } : suggestion;
+    }
+    async render(remainingLines) {
+        await this._loadSuggestions();
+        if (!this.#suggestBlob) {
+            return { data: "", rows: 0 };
+        }
+        const { suggestions, argumentDescription } = this.#suggestBlob;
+        const page = Math.min(Math.floor(this.#activeSuggestionIdx / maxSuggestions) + 1, Math.floor(suggestions.length / maxSuggestions) + 1);
+        const pagedSuggestions = suggestions.filter((_, idx) => idx < page * maxSuggestions && idx >= (page - 1) * maxSuggestions);
+        const activePagedSuggestionIndex = this.#activeSuggestionIdx % maxSuggestions;
+        const activeDescription = pagedSuggestions.at(activePagedSuggestionIndex)?.description || argumentDescription || "";
+        const wrappedPadding = this.#term.getCursorState().cursorX % this.#term.cols;
+        const maxPadding = activeDescription.length !== 0 ? this.#term.cols - suggestionWidth - descriptionWidth : this.#term.cols - suggestionWidth;
+        const swapDescription = wrappedPadding > maxPadding && activeDescription.length !== 0;
+        const swappedPadding = swapDescription ? Math.max(wrappedPadding - descriptionWidth, 0) : wrappedPadding;
+        const clampedLeftPadding = Math.min(Math.min(wrappedPadding, swappedPadding), maxPadding);
+        if (suggestions.length <= this.#activeSuggestionIdx) {
+            this.#activeSuggestionIdx = Math.max(suggestions.length - 1, 0);
+        }
+        if (pagedSuggestions.length == 0) {
+            if (argumentDescription != null) {
+                return {
+                    data: ansi.cursorHide +
+                        ansi.cursorUp(2) +
+                        ansi.cursorForward(clampedLeftPadding) +
+                        this._renderArgumentDescription(argumentDescription, clampedLeftPadding),
+                    rows: 3,
+                };
+            }
+            return { data: "", rows: 0 };
+        }
+        const suggestionRowsUsed = pagedSuggestions.length + borderWidth;
+        let descriptionRowsUsed = this._descriptionRows(activeDescription) + borderWidth;
+        let rows = Math.max(descriptionRowsUsed, suggestionRowsUsed);
+        if (rows <= remainingLines) {
+            descriptionRowsUsed = suggestionRowsUsed;
+            rows = suggestionRowsUsed;
+        }
+        const descriptionUI = ansi.cursorUp(descriptionRowsUsed - 1) +
+            (swapDescription
+                ? this._renderDescription(activeDescription, clampedLeftPadding)
+                : this._renderDescription(activeDescription, clampedLeftPadding + suggestionWidth)) +
+            ansi.cursorDown(descriptionRowsUsed - 1);
+        const suggestionUI = ansi.cursorUp(suggestionRowsUsed - 1) +
+            (swapDescription
+                ? this._renderSuggestions(pagedSuggestions, activePagedSuggestionIndex, clampedLeftPadding + descriptionWidth)
+                : this._renderSuggestions(pagedSuggestions, activePagedSuggestionIndex, clampedLeftPadding)) +
+            ansi.cursorDown(suggestionRowsUsed - 1);
+        const ui = swapDescription ? descriptionUI + suggestionUI : suggestionUI + descriptionUI;
+        return {
+            data: ansi.cursorHide + ansi.cursorForward(clampedLeftPadding) + ui + ansi.cursorShow,
+            rows,
+        };
+    }
+    update(keyPress) {
+        const { name, shift, ctrl } = keyPress;
+        if (name == "return") {
+            this.#term.clearCommand(); // clear the current command on enter
+        }
+        // if suggestions are hidden, keep them hidden until during command navigation
+        if (this.#hideSuggestions) {
+            this.#hideSuggestions = name == "up" || name == "down";
+        }
+        if (!this.#suggestBlob) {
+            return false;
+        }
+        const { dismissSuggestions: { key: dismissKey, shift: dismissShift, control: dismissCtrl }, acceptSuggestion: { key: acceptKey, shift: acceptShift, control: acceptCtrl }, nextSuggestion: { key: nextKey, shift: nextShift, control: nextCtrl }, previousSuggestion: { key: prevKey, shift: prevShift, control: prevCtrl }, } = getConfig().bindings;
+        if (name == dismissKey && shift == !!dismissShift && ctrl == !!dismissCtrl) {
+            this.#suggestBlob = undefined;
+            this.#hideSuggestions = true;
+        }
+        else if (name == prevKey && shift == !!prevShift && ctrl == !!prevCtrl) {
+            this.#activeSuggestionIdx = Math.max(0, this.#activeSuggestionIdx - 1);
+        }
+        else if (name == nextKey && shift == !!nextShift && ctrl == !!nextCtrl) {
+            this.#activeSuggestionIdx = Math.min(this.#activeSuggestionIdx + 1, (this.#suggestBlob?.suggestions.length ?? 1) - 1);
+        }
+        else if (name == acceptKey && shift == !!acceptShift && ctrl == !!acceptCtrl) {
+            const removals = "\u007F".repeat(this.#suggestBlob?.charactersToDrop ?? 0);
+            const suggestion = this.#suggestBlob?.suggestions.at(this.#activeSuggestionIdx);
+            const chars = suggestion?.insertValue ?? suggestion?.name + " ";
+            if (this.#suggestBlob == null || !chars.trim() || this.#suggestBlob?.suggestions.length == 0) {
+                return false;
+            }
+            this.#term.write(removals + chars);
+        }
+        else {
+            return false;
+        }
+        log.debug({ msg: "handled keypress", ...keyPress });
+        return true;
+    }
+}

package/build/ui/ui-doctor.js

@@ -0,0 +1,69 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import chalk from "chalk";
+import { checkLegacyConfigs, checkShellConfigPlugin, checkShellConfigs } from "../utils/shell.js";
+export const render = async () => {
+    let errors = 0;
+    errors += await renderLegacyConfigIssues();
+    errors += await renderShellPluginIssues();
+    errors += renderShellConfigIssues();
+    process.exit(errors);
+};
+const renderLegacyConfigIssues = async () => {
+    const shellsWithLegacyConfigs = await checkLegacyConfigs();
+    if (shellsWithLegacyConfigs.length > 0) {
+        process.stderr.write(chalk.red("•") + chalk.bold(" detected legacy configurations\n"));
+        process.stderr.write("  the following shells have legacy configurations:\n");
+        shellsWithLegacyConfigs.forEach((shell) => {
+            process.stderr.write(chalk.red("  - ") + shell + "\n");
+        });
+        process.stderr.write(chalk.yellow("  remove any inshellisense configurations from your shell profile and re-add them following the instructions in the README\n"));
+        return 1;
+    }
+    else {
+        process.stdout.write(chalk.green("✓") + " no legacy configurations found\n");
+    }
+    return 0;
+};
+const renderShellConfigIssues = () => {
+    const shellsWithoutConfigs = checkShellConfigs();
+    if (shellsWithoutConfigs.length > 0) {
+        process.stderr.write(chalk.red("•") + " the following shells do not have configurations:\n");
+        shellsWithoutConfigs.forEach((shell) => {
+            process.stderr.write(chalk.red("  - ") + shell + "\n");
+        });
+        process.stderr.write(chalk.yellow("  run " + chalk.underline(chalk.cyan("is init --generate-full-configs")) + " to generate new configurations\n"));
+        return 1;
+    }
+    else {
+        process.stdout.write(chalk.green("✓") + " all shells have configurations\n");
+    }
+    return 0;
+};
+const renderShellPluginIssues = async () => {
+    const { shellsWithoutPlugin, shellsWithBadPlugin } = await checkShellConfigPlugin();
+    if (shellsWithoutPlugin.length == 0) {
+        process.stdout.write(chalk.green("✓") + " all shells have plugins\n");
+    }
+    else {
+        process.stderr.write(chalk.red("•") + " the following shells do not have the plugin installed:\n");
+        shellsWithoutPlugin.forEach((shell) => {
+            process.stderr.write(chalk.red("  - ") + shell + "\n");
+        });
+        process.stderr.write(chalk.yellow("  review the README to generate the missing shell plugins, this warning can be ignored if you prefer manual startup\n"));
+    }
+    if (shellsWithBadPlugin.length == 0) {
+        process.stdout.write(chalk.green("✓") + " all shells have correct plugins\n");
+    }
+    else {
+        process.stderr.write(chalk.red("•") + " the following shells have plugins incorrectly installed:\n");
+        shellsWithBadPlugin.forEach((shell) => {
+            process.stderr.write(chalk.red("  - ") + shell + "\n");
+        });
+        process.stderr.write(chalk.yellow("  remove and regenerate the plugins according to the README, only whitespace can be after the shell plugins\n"));
+    }
+    if (shellsWithoutPlugin.length > 0 || shellsWithBadPlugin.length > 0) {
+        return 1;
+    }
+    return 0;
+};