@microsoft/inshellisense 0.0.1-rc.10 → 0.0.1-rc.12

package/README.md

@@ -22,12 +22,11 @@ After completing the installation, you can run `is` to start the autocomplete se
 
 ### Usage
 
-| Action                                | Command                           | Description                                      |
-| ------------------------------------- | --------------------------------- | ------------------------------------------------ |
-| Start                                 | `is`                              | Start inshellisense session on the current shell |
-| Stop                                  | `exit`                            | Stop inshellisense session on the current shell  |
-| Check If Inside Inshellisense Session | `is -c`                           | Check if shell inside inshellisense session      |
-
+| Action                                | Command | Description                                      |
+| ------------------------------------- | ------- | ------------------------------------------------ |
+| Start                                 | `is`    | Start inshellisense session on the current shell |
+| Stop                                  | `exit`  | Stop inshellisense session on the current shell  |
+| Check If Inside Inshellisense Session | `is -c` | Check if shell inside inshellisense session      |
 
 #### Keybindings
 
@@ -51,6 +50,7 @@ inshellisense supports the following shells:
 - [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)_
 - [xonsh](https://xon.sh/)
+- [nushell](https://www.nushell.sh/)
 
 ## Configuration
 

package/build/commands/root.js

@@ -5,6 +5,8 @@ import { Shell, supportedShells as shells, setupZshDotfiles, setupBashPreExec }
 import { inferShell } from "../utils/shell.js";
 import { loadConfig } from "../utils/config.js";
 import log from "../utils/log.js";
+import { loadAliases } from "../runtime/alias.js";
+import { loadLocalSpecsSet } from "../runtime/runtime.js";
 export const supportedShells = shells.join(", ");
 export const action = (program) => async (options) => {
     const inISTerm = process.env.ISTERM === "1";
@@ -15,6 +17,7 @@ export const action = (program) => async (options) => {
     if (options.verbose)
         await log.enable();
     await loadConfig(program);
+    await loadLocalSpecsSet();
     const shell = options.shell ?? (await inferShell());
     if (shell == null) {
         program.error(`Unable to identify shell, use the -s/--shell option to provide your shell`, { exitCode: 1 });
@@ -28,5 +31,6 @@ export const action = (program) => async (options) => {
     else if (shell == Shell.Bash) {
         await setupBashPreExec();
     }
+    await loadAliases(shell);
     await render(shell, options.test ?? false, options.parentTermExit ?? false);
 };

package/build/isterm/commandManager.js

@@ -2,21 +2,23 @@
 // Licensed under the MIT License.
 import convert from "color-convert";
 import os from "node:os";
-import { Shell } from "../utils/shell.js";
+import { getShellPromptRewrites, Shell } from "../utils/shell.js";
 import log from "../utils/log.js";
 import { getConfig } from "../utils/config.js";
 const maxPromptPollDistance = 10;
 export class CommandManager {
     #activeCommand;
-    #previousCommandLines;
     #terminal;
+    #previousCommandLines;
     #shell;
+    #promptRewrites;
     #supportsProperOscPlacements = os.platform() !== "win32";
     constructor(terminal, shell) {
         this.#terminal = terminal;
         this.#shell = shell;
         this.#activeCommand = {};
         this.#previousCommandLines = new Set();
+        this.#promptRewrites = getShellPromptRewrites(shell);
         if (this.#supportsProperOscPlacements) {
             this.#terminal.parser.registerCsiHandler({ final: "J" }, (params) => {
                 if (params.at(0) == 3 || params.at(0) == 2) {
@@ -27,12 +29,11 @@ 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() {
+        if (this.#activeCommand.promptEndMarker != null)
+            return;
         this.#activeCommand.promptEndMarker = this.#terminal.registerMarker(0);
         if (this.#activeCommand.promptEndMarker?.line === this.#terminal.buffer.active.cursorY) {
             this.#activeCommand.promptEndX = this.#terminal.buffer.active.cursorX;
@@ -46,6 +47,15 @@ export class CommandManager {
         this.handlePromptStart();
         this.#previousCommandLines = new Set();
     }
+    _extractPrompt(lineText, patterns) {
+        for (const { regex, postfix } of patterns) {
+            const customPrompt = lineText.match(new RegExp(regex))?.groups?.prompt;
+            const adjustedPrompt = this._adjustPrompt(customPrompt, lineText, postfix);
+            if (adjustedPrompt) {
+                return adjustedPrompt;
+            }
+        }
+    }
     _getWindowsPrompt(y) {
         const line = this.#terminal.buffer.active.getLine(y);
         if (!line) {
@@ -59,13 +69,9 @@ export class CommandManager {
         const inshellisenseConfig = getConfig();
         if (this.#shell == Shell.Bash) {
             if (inshellisenseConfig?.prompt?.bash != null) {
-                for (const { regex, postfix } of inshellisenseConfig.prompt.bash) {
-                    const customPrompt = lineText.match(new RegExp(regex))?.groups?.prompt;
-                    const adjustedPrompt = this._adjustPrompt(customPrompt, lineText, postfix);
-                    if (adjustedPrompt) {
-                        return adjustedPrompt;
-                    }
-                }
+                const extractedPrompt = this._extractPrompt(lineText, inshellisenseConfig.prompt.bash);
+                if (extractedPrompt)
+                    return extractedPrompt;
             }
             const bashPrompt = lineText.match(/^(?<prompt>.*\$\s?)/)?.groups?.prompt;
             if (bashPrompt) {
@@ -75,15 +81,25 @@ export class CommandManager {
                 }
             }
         }
+        if (this.#shell == Shell.Nushell) {
+            if (inshellisenseConfig?.prompt?.nu != null) {
+                const extractedPrompt = this._extractPrompt(lineText, inshellisenseConfig.prompt.nu);
+                if (extractedPrompt)
+                    return extractedPrompt;
+            }
+            const nushellPrompt = lineText.match(/(?<prompt>.*>\s?)/)?.groups?.prompt;
+            if (nushellPrompt) {
+                const adjustedPrompt = this._adjustPrompt(nushellPrompt, lineText, ">");
+                if (adjustedPrompt) {
+                    return adjustedPrompt;
+                }
+            }
+        }
         if (this.#shell == Shell.Xonsh) {
             if (inshellisenseConfig?.prompt?.xonsh != null) {
-                for (const { regex, postfix } of inshellisenseConfig.prompt.xonsh) {
-                    const customPrompt = lineText.match(new RegExp(regex))?.groups?.prompt;
-                    const adjustedPrompt = this._adjustPrompt(customPrompt, lineText, postfix);
-                    if (adjustedPrompt) {
-                        return adjustedPrompt;
-                    }
-                }
+                const extractedPrompt = this._extractPrompt(lineText, inshellisenseConfig.prompt.xonsh);
+                if (extractedPrompt)
+                    return extractedPrompt;
             }
             let xonshPrompt = lineText.match(/(?<prompt>.*@\s?)/)?.groups?.prompt;
             if (xonshPrompt) {
@@ -102,22 +118,14 @@ export class CommandManager {
         }
         if (this.#shell == Shell.Powershell || this.#shell == Shell.Pwsh) {
             if (inshellisenseConfig?.prompt?.powershell != null) {
-                for (const { regex, postfix } of inshellisenseConfig.prompt.powershell) {
-                    const customPrompt = lineText.match(new RegExp(regex))?.groups?.prompt;
-                    const adjustedPrompt = this._adjustPrompt(customPrompt, lineText, postfix);
-                    if (adjustedPrompt) {
-                        return adjustedPrompt;
-                    }
-                }
+                const extractedPrompt = this._extractPrompt(lineText, inshellisenseConfig.prompt.powershell);
+                if (extractedPrompt)
+                    return extractedPrompt;
             }
             if (inshellisenseConfig?.prompt?.pwsh != null) {
-                for (const { regex, postfix } of inshellisenseConfig.prompt.pwsh) {
-                    const customPrompt = lineText.match(new RegExp(regex))?.groups?.prompt;
-                    const adjustedPrompt = this._adjustPrompt(customPrompt, lineText, postfix);
-                    if (adjustedPrompt) {
-                        return adjustedPrompt;
-                    }
-                }
+                const extractedPrompt = this._extractPrompt(lineText, inshellisenseConfig.prompt.pwsh);
+                if (extractedPrompt)
+                    return extractedPrompt;
             }
             const pwshPrompt = lineText.match(/(?<prompt>(\(.+\)\s)?(?:PS.+>\s?))/)?.groups?.prompt;
             if (pwshPrompt) {
@@ -195,7 +203,7 @@ export class CommandManager {
         // if we haven't fond the prompt yet, poll over the next 5 lines searching for it
         if (this.#activeCommand.promptText == null && withinPollDistance) {
             for (let i = globalCursorPosition; i < this.#activeCommand.promptEndMarker.line + maxPromptPollDistance; i++) {
-                if (this.#previousCommandLines.has(i))
+                if (this.#previousCommandLines.has(i) && !this.#promptRewrites)
                     continue;
                 const promptResult = this._getWindowsPrompt(i);
                 if (promptResult != null) {
@@ -212,9 +220,13 @@ export class CommandManager {
             let lineY = this.#activeCommand.promptEndMarker.line;
             let line = this.#terminal.buffer.active.getLine(this.#activeCommand.promptEndMarker.line);
             let command = "";
+            let wrappedCommand = "";
             let suggestions = "";
+            let isWrapped = false;
             for (;;) {
                 for (let i = lineY == this.#activeCommand.promptEndMarker.line ? this.#activeCommand.promptText.length : 0; i < this.#terminal.cols; i++) {
+                    if (command.endsWith("    "))
+                        break; // assume that a command that ends with 4 spaces is terminated, avoids capturing right prompts
                     const cell = line?.getCell(i);
                     if (cell == null)
                         continue;
@@ -222,6 +234,7 @@ export class CommandManager {
                     const cleanedChars = chars == "" ? " " : chars;
                     if (!this._isSuggestion(cell) && suggestions.length == 0) {
                         command += cleanedChars;
+                        wrappedCommand += cleanedChars;
                     }
                     else {
                         suggestions += cleanedChars;
@@ -229,11 +242,16 @@ export class CommandManager {
                 }
                 lineY += 1;
                 line = this.#terminal.buffer.active.getLine(lineY);
-                if (!line?.isWrapped) {
+                const wrapped = line?.isWrapped || this.#terminal.buffer.active.cursorY + this.#terminal.buffer.active.baseY != lineY - 1;
+                isWrapped = isWrapped || wrapped;
+                if (!wrapped) {
                     break;
                 }
+                wrappedCommand = "";
             }
-            const cursorAtEndOfInput = (this.#activeCommand.promptText.length + command.trim().length) % this.#terminal.cols <= this.#terminal.buffer.active.cursorX;
+            const cursorAtEndOfInput = isWrapped
+                ? wrappedCommand.trim().length % this.#terminal.cols <= this.#terminal.buffer.active.cursorX
+                : (this.#activeCommand.promptText.length + command.trimEnd().length) % this.#terminal.cols <= this.#terminal.buffer.active.cursorX;
             let hasOutput = false;
             let cell = undefined;
             for (let i = 0; i < this.#terminal.cols; i++) {
@@ -245,7 +263,10 @@ export class CommandManager {
                     break;
                 }
             }
-            const commandPostfix = this.#activeCommand.promptText.length + command.trim().length < this.#terminal.buffer.active.cursorX ? " " : "";
+            const postfixActive = isWrapped
+                ? wrappedCommand.trim().length < this.#terminal.buffer.active.cursorX
+                : this.#activeCommand.promptText.length + command.trimEnd().length < this.#terminal.buffer.active.cursorX;
+            const commandPostfix = postfixActive ? " " : "";
             this.#activeCommand.persistentOutput = this.#activeCommand.hasOutput && hasOutput;
             this.#activeCommand.hasOutput = hasOutput;
             this.#activeCommand.suggestionsText = suggestions.trim();

package/build/isterm/pty.js

@@ -7,7 +7,7 @@ import path from "node:path";
 import url from "node:url";
 import fs from "node:fs";
 import pty from "@homebridge/node-pty-prebuilt-multiarch";
-import { Shell, getPythonPath, userZdotdir, zdotdir } from "../utils/shell.js";
+import { Shell, userZdotdir, zdotdir } from "../utils/shell.js";
 import { IsTermOscPs, IstermOscPt, IstermPromptStart, IstermPromptEnd } from "../utils/ansi.js";
 import xterm from "@xterm/headless";
 import { CommandManager } from "./commandManager.js";
@@ -143,6 +143,26 @@ export class ISTerm {
             cursorY: this.#term.buffer.active.cursorY,
         };
     }
+    _sameAccent(baseCell, targetCell) {
+        return baseCell?.isBold() == targetCell?.isBold() && baseCell?.isItalic() == targetCell?.isItalic() && baseCell?.isUnderline() == targetCell?.isUnderline();
+    }
+    _getAnsiAccents(cell) {
+        if (cell == null)
+            return "";
+        let boldAnsi = "";
+        if (cell.isBold()) {
+            boldAnsi = "\x1b[1m";
+        }
+        let italicAnsi = "";
+        if (cell.isItalic()) {
+            italicAnsi = "\x1b[3m";
+        }
+        let underlineAnsi = "";
+        if (cell.isUnderline()) {
+            underlineAnsi = "\x1b[4m";
+        }
+        return boldAnsi + italicAnsi + underlineAnsi;
+    }
     _sameColor(baseCell, targetCell) {
         return (baseCell?.getBgColorMode() == targetCell?.getBgColorMode() &&
             baseCell?.getBgColor() == targetCell?.getBgColor() &&
@@ -190,6 +210,9 @@ export class ISTerm {
                 if (!this._sameColor(prevCell, cell)) {
                     ansiLine.push(this._getAnsiColors(cell));
                 }
+                if (!this._sameAccent(prevCell, cell)) {
+                    ansiLine.push(this._getAnsiAccents(cell));
+                }
                 ansiLine.push(chars == "" ? " " : chars);
                 prevCell = cell;
             }
@@ -214,12 +237,12 @@ export class ISTerm {
     }
 }
 export const spawn = async (options) => {
-    const { shellTarget, shellArgs } = await convertToPtyTarget(options.shell);
+    const { shellTarget, shellArgs } = await convertToPtyTarget(options.shell, options.underTest);
     return new ISTerm({ ...options, shellTarget, shellArgs });
 };
-const convertToPtyTarget = async (shell) => {
+const convertToPtyTarget = async (shell, underTest) => {
     const platform = os.platform();
-    let shellTarget = shell == Shell.Bash && platform == "win32" ? await gitBashPath() : platform == "win32" ? `${shell}.exe` : shell;
+    const shellTarget = shell == Shell.Bash && platform == "win32" ? await gitBashPath() : platform == "win32" ? `${shell}.exe` : shell;
     const shellFolderPath = path.join(path.dirname(url.fileURLToPath(import.meta.url)), "..", "..", "shell");
     let shellArgs = [];
     switch (shell) {
@@ -241,10 +264,14 @@ const convertToPtyTarget = async (shell) => {
                 path.join(os.homedir(), ".config", "xonsh", "rc.d"),
             ];
             const configs = [sharedConfig, ...userConfigs].filter((config) => fs.existsSync(config));
-            shellArgs = ["-m", "xonsh", "--rc", ...configs, path.join(shellFolderPath, "shellIntegration.xsh")];
-            shellTarget = await getPythonPath();
+            shellArgs = ["--rc", ...configs, path.join(shellFolderPath, "shellIntegration.xsh")];
             break;
         }
+        case Shell.Nushell:
+            shellArgs = ["-e", `source \`${path.join(shellFolderPath, "shellIntegration.nu")}\``];
+            if (underTest)
+                shellArgs.push("-n");
+            break;
     }
     return { shellTarget, shellArgs };
 };
@@ -252,8 +279,9 @@ const convertToPtyEnv = (shell, underTest) => {
     const env = {
         ...process.env,
         ISTERM: "1",
-        ISTERM_TESTING: underTest ? "1" : undefined,
     };
+    if (underTest)
+        env.ISTERM_TESTING = "1";
     switch (shell) {
         case Shell.Cmd: {
             if (underTest) {

package/build/runtime/alias.js

@@ -0,0 +1,60 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import log from "../utils/log.js";
+import { gitBashPath, Shell } from "../utils/shell.js";
+import { parseCommand } from "./parser.js";
+import { buildExecuteShellCommand } from "./utils.js";
+import os from "node:os";
+const loadedAliases = {};
+const platform = os.platform();
+const executeShellCommand = buildExecuteShellCommand(5000);
+const loadBashAliases = async () => {
+    const shellTarget = platform == "win32" ? await gitBashPath() : Shell.Bash;
+    const { stdout, stderr, status } = await executeShellCommand({ command: shellTarget, args: ["-i", "-c", "alias"], cwd: process.cwd() });
+    if (status !== 0) {
+        log.debug({ msg: "failed to load bash aliases", stderr, status });
+        return;
+    }
+    return stdout
+        .trim()
+        .split("\n")
+        .forEach((line) => {
+        const [alias, ...commandSegments] = line.replace("alias ", "").replaceAll("'\\''", "'").split("=");
+        loadedAliases[alias] = parseCommand(commandSegments.join("=").slice(1, -1) + " ");
+    });
+};
+const loadZshAliases = async () => {
+    const { stdout, stderr, status } = await executeShellCommand({ command: Shell.Zsh, args: ["-i", "-c", "alias"], cwd: process.cwd() });
+    if (status !== 0) {
+        log.debug({ msg: "failed to load zsh aliases", stderr, status });
+        return;
+    }
+    return stdout
+        .trim()
+        .split("\n")
+        .forEach((line) => {
+        const [alias, ...commandSegments] = line.replaceAll("'\\''", "'").split("=");
+        loadedAliases[alias] = parseCommand(commandSegments.join("=").slice(1, -1) + " ");
+    });
+};
+export const loadAliases = async (shell) => {
+    switch (shell) {
+        case Shell.Bash:
+            await loadBashAliases();
+            break;
+        case Shell.Zsh:
+            await loadZshAliases();
+            break;
+    }
+    return [];
+};
+export const aliasExpand = (command) => {
+    if (!command.at(0)?.complete)
+        return command;
+    const alias = loadedAliases[command.at(0)?.token ?? ""];
+    if (alias) {
+        log.debug({ msg: "expanding alias", alias, command: command.slice(1) });
+        return [...alias, ...command.slice(1)];
+    }
+    return command;
+};

package/build/runtime/runtime.js

@@ -8,25 +8,31 @@ import path from "node:path";
 import { parseCommand } from "./parser.js";
 import { getArgDrivenRecommendation, getSubcommandDrivenRecommendation } from "./suggestion.js";
 import { buildExecuteShellCommand, resolveCwd } from "./utils.js";
+import { aliasExpand } from "./alias.js";
+import { getConfig } from "../utils/config.js";
+import log from "../utils/log.js";
 // eslint-disable-next-line @typescript-eslint/no-explicit-any -- recursive type, setting as any
 const specSet = {};
-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] = `@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);
@@ -50,12 +56,32 @@ const lazyLoadSpec = async (key) => {
 const lazyLoadSpecLocation = async (location) => {
     return; //TODO: implement spec location loading
 };
+export const loadLocalSpecsSet = async () => {
+    const specsPath = getConfig()?.specs?.path;
+    if (!specsPath) {
+        return;
+    }
+    try {
+        await Promise.allSettled(specsPath.map((specPath) => import(path.join(specPath, "index.js"))
+            .then((res) => {
+            const { default: speclist, diffVersionedCompletions: versionedSpeclist } = res;
+            loadSpecsSet(speclist, versionedSpeclist, specPath);
+        })
+            .catch((e) => {
+            log.debug({ msg: "load local spec failed", e: e.message, specPath });
+        })));
+    }
+    catch (e) {
+        log.debug({ msg: "load local specs failed", e: e.message, specsPath });
+    }
+};
 export const getSuggestions = async (cmd, cwd, shell) => {
-    const activeCmd = parseCommand(cmd);
+    let activeCmd = parseCommand(cmd);
     const rootToken = activeCmd.at(0);
     if (activeCmd.length === 0 || !rootToken?.complete) {
         return;
     }
+    activeCmd = aliasExpand(activeCmd);
     const spec = await loadSpec(activeCmd);
     if (spec == null)
         return;
@@ -127,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": {
@@ -164,7 +202,10 @@ const runOption = async (tokens, option, subcommand, cwd, persistentOptions, acc
         const args = option.args instanceof Array ? option.args : [option.args];
         return runArg(tokens.slice(1), args, subcommand, cwd, persistentOptions, acceptedTokens.concat(activeToken), true, false);
     }
-    return runSubcommand(tokens.slice(1), subcommand, cwd, persistentOptions, acceptedTokens.concat({ ...activeToken, isPersistent }));
+    return runSubcommand(tokens.slice(1), subcommand, cwd, persistentOptions, acceptedTokens.concat({
+        ...activeToken,
+        isPersistent,
+    }));
 };
 const runArg = async (tokens, args, subcommand, cwd, persistentOptions, acceptedTokens, fromOption, fromVariadic) => {
     if (args.length === 0) {

package/build/runtime/template.js

@@ -4,11 +4,20 @@ 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" } }));
+    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 (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" } }));
+    return files
+        .filter((f) => f.isDirectory())
+        .map((f) => ({
+        name: f.name,
+        priority: 55,
+        context: { templateType: "folders" },
+        type: "folder",
+    }));
 };
 // TODO: implement history template
 const historyTemplate = () => {

package/build/runtime/utils.js

@@ -3,7 +3,7 @@
 import path from "node:path";
 import { spawn } from "node:child_process";
 import fsAsync from "node:fs/promises";
-import { Shell } from "../utils/shell.js";
+import { getPathSeperator } from "../utils/shell.js";
 import log from "../utils/log.js";
 export const buildExecuteShellCommand = (timeout) => async ({ command, env, args, cwd }) => {
     const child = spawn(command, args, { cwd, env });
@@ -29,7 +29,7 @@ export const resolveCwd = async (cmdToken, cwd, shell) => {
     if (cmdToken == null)
         return { cwd, pathy: false, complete: false };
     const { token } = cmdToken;
-    const sep = shell == Shell.Bash ? "/" : path.sep;
+    const sep = getPathSeperator(shell);
     if (!token.includes(sep))
         return { cwd, pathy: false, complete: false };
     const resolvedCwd = path.isAbsolute(token) ? token : path.join(cwd, token);

package/build/ui/ui-root.js

@@ -4,7 +4,7 @@ import readline from "node:readline";
 import ansi from "ansi-escapes";
 import chalk from "chalk";
 import log from "../utils/log.js";
-import { Shell } from "../utils/shell.js";
+import { getBackspaceSequence } from "../utils/shell.js";
 import isterm from "../isterm/index.js";
 import { eraseLinesBelow } from "../utils/ansi.js";
 import { SuggestionManager, MAX_LINES } from "./suggestionManager.js";
@@ -120,8 +120,8 @@ export const render = async (shell, underTest, parentTermExit) => {
             term.noop();
         }
         else if (!inputHandled) {
-            if (press.name == "backspace" && (shell === Shell.Pwsh || shell === Shell.Powershell || shell === Shell.Cmd)) {
-                term.write("\u007F");
+            if (press.name == "backspace") {
+                term.write(getBackspaceSequence(keyPress, shell));
             }
             else {
                 term.write(press.sequence);

package/build/utils/config.js

@@ -30,6 +30,11 @@ const promptPatternsSchema = {
         required: ["regex", "postfix"],
     },
 };
+const specPathsSchema = {
+    type: "array",
+    items: { type: "string" },
+    nullable: true,
+};
 const configSchema = {
     type: "object",
     nullable: true,
@@ -52,6 +57,14 @@ const configSchema = {
                 pwsh: promptPatternsSchema,
                 powershell: promptPatternsSchema,
                 xonsh: promptPatternsSchema,
+                nu: promptPatternsSchema,
+            },
+        },
+        specs: {
+            type: "object",
+            nullable: true,
+            properties: {
+                path: specPathsSchema,
             },
         },
     },
@@ -95,6 +108,10 @@ export const loadConfig = async (program) => {
                 powershell: config.prompt?.powershell,
                 xonsh: config.prompt?.xonsh,
                 pwsh: config.prompt?.pwsh,
+                nu: config.prompt?.nu,
+            },
+            specs: {
+                path: [`${os.homedir()}/.fig/autocomplete/build`, ...(config?.specs?.path ?? [])],
             },
         };
     }

package/build/utils/shell.js

@@ -17,6 +17,7 @@ export var Shell;
     Shell["Fish"] = "fish";
     Shell["Cmd"] = "cmd";
     Shell["Xonsh"] = "xonsh";
+    Shell["Nushell"] = "nu";
 })(Shell || (Shell = {}));
 export const supportedShells = [
     Shell.Bash,
@@ -26,6 +27,7 @@ export const supportedShells = [
     Shell.Fish,
     process.platform == "win32" ? Shell.Cmd : null,
     Shell.Xonsh,
+    Shell.Nushell,
 ].filter((shell) => shell != null);
 export const userZdotdir = process.env?.ZDOTDIR ?? os.homedir() ?? `~`;
 export const zdotdir = path.join(os.tmpdir(), `is-zsh`);
@@ -68,9 +70,6 @@ export const gitBashPath = async () => {
     }
     throw new Error("unable to find a git bash executable installed");
 };
-export const getPythonPath = async () => {
-    return await which("python", { nothrow: true });
-};
 const getGitBashPaths = async () => {
     const gitDirs = new Set();
     const gitExePath = await which("git.exe", { nothrow: true });
@@ -96,3 +95,7 @@ const getGitBashPaths = async () => {
     gitBashPaths.push(`${process.env["UserProfile"]}\\scoop\\apps\\git-with-openssh\\current\\bin\\bash.exe`);
     return gitBashPaths;
 };
+export const getBackspaceSequence = (press, shell) => shell === Shell.Pwsh || shell === Shell.Powershell || shell === Shell.Cmd || shell === Shell.Nushell ? "\u007F" : press[1].sequence;
+export const getPathSeperator = (shell) => (shell == Shell.Bash || shell == Shell.Xonsh || shell == Shell.Nushell ? "/" : path.sep);
+// nu fully re-writes the prompt every keystroke resulting in duplicate start/end sequences on the same line
+export const getShellPromptRewrites = (shell) => shell == Shell.Nushell;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@microsoft/inshellisense",
-  "version": "0.0.1-rc.10",
+  "version": "0.0.1-rc.12",
   "description": "IDE style command line auto complete",
   "type": "module",
   "engines": {

package/shell/shellIntegration.bash

@@ -1,16 +1,6 @@
 if [ -r ~/.bashrc ]; then
     . ~/.bashrc
 fi
-if [ -r /etc/profile ]; then
-    . /etc/profile
-fi
-if [ -r ~/.bash_profile ]; then
-    . ~/.bash_profile
-elif [ -r ~/.bash_login ]; then
-    . ~/.bash_login
-elif [ -r ~/.profile ]; then
-    . ~/.profile
-fi
 
 if [ -r ~/.inshellisense/bash-preexec.sh ]; then
     . ~/.inshellisense/bash-preexec.sh
@@ -62,7 +52,7 @@ __is_precmd() {
 __is_update_prompt() {
 	if [[ "$__is_custom_PS1" == "" || "$__is_custom_PS1" != "$PS1" ]]; then
         __is_original_PS1=$PS1
-		if [ $ISTERM_TESTING == "1" ]; then
+		if [[ $ISTERM_TESTING == "1" ]]; then
 			__is_original_PS1="> "
 		fi
         __is_custom_PS1="\[$(__is_prompt_start)\]$__is_original_PS1\[$(__is_prompt_end)\]"

package/shell/shellIntegration.nu

@@ -0,0 +1,28 @@
+let __is_escape_value = {|x| $x | str replace --all "\\" "\\\\" | str replace --all ";" "\\x3b" }
+
+let __is_update_cwd = { 
+    let pwd = do $__is_escape_value $env.PWD
+    $"\e]6973;CWD;($pwd)\a" 
+}
+let __is_original_PROMPT_COMMAND = if 'PROMPT_COMMAND' in $env { $env.PROMPT_COMMAND } else { "" }
+let __is_custom_PROMPT_COMMAND = {
+    let promptCommandType = $__is_original_PROMPT_COMMAND | describe
+    mut cmd = if $promptCommandType == "closure" { do $__is_original_PROMPT_COMMAND } else { $__is_original_PROMPT_COMMAND }
+    let pwd = do $__is_update_cwd
+    if 'ISTERM_TESTING' in $env {
+        $cmd = ""
+    }
+    $"\e]6973;PS\a($cmd)($pwd)"
+}
+$env.PROMPT_COMMAND = $__is_custom_PROMPT_COMMAND
+
+let __is_original_PROMPT_INDICATOR = if 'PROMPT_INDICATOR' in $env { $env.PROMPT_INDICATOR } else { "" }
+let __is_custom_PROMPT_INDICATOR = {
+    let indicatorCommandType = $__is_original_PROMPT_INDICATOR | describe
+    mut ind = if $indicatorCommandType == "closure" { do $__is_original_PROMPT_INDICATOR } else { $__is_original_PROMPT_INDICATOR }
+    if 'ISTERM_TESTING' in $env {
+        $ind = "> "
+    }
+    $"($ind)\e]6973;PE\a"
+}
+$env.PROMPT_INDICATOR = $__is_custom_PROMPT_INDICATOR

package/shell/shellIntegration.xsh

@@ -23,7 +23,7 @@ def __is_update_cwd() -> str:
 $PROMPT_FIELDS['__is_prompt_start'] = __is_prompt_start
 $PROMPT_FIELDS['__is_prompt_end'] = __is_prompt_end
 $PROMPT_FIELDS['__is_update_cwd'] = __is_update_cwd
-if $ISTERM_TESTING:
+if 'ISTERM_TESTING' in ${...}:
     $PROMPT = "> "
 
 $PROMPT = "{__is_prompt_start}{__is_update_cwd}" + $PROMPT + "{__is_prompt_end}"