@microsoft/inshellisense 0.0.1-rc.16 → 0.0.1-rc.18

package/README.md

@@ -18,7 +18,7 @@ npm install -g @microsoft/inshellisense
 
 ### Quickstart
 
-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.
+After completing the installation, run `is doctor` to verify your installation was successful. You can run `is` to start the autocomplete session for your desired shell. Additionally, inshellisense is also aliased under `inshellisense` after installation.
 
 ### Shell Plugin
 
@@ -35,19 +35,20 @@ is init zsh >> ~/.zshrc
 is init fish >> ~/.config/fish/config.fish
 
 # pwsh
-is init pwsh >> $profile
+is init pwsh | Add-Content $profile
 
 # powershell
-is init powershell >> $profile
+is init powershell | Add-Content $profile
 
 # xonsh
 is init xonsh >> ~/.xonshrc
 
 # nushell
-is init nu >> $nu.env-path
+is init nu | save $nu.env-path --append
 ```
 
-When updating your shell configuration in the future, make sure the inshellisense plugin is the last command in the file.
+> [!NOTE]  
+> When updating your shell configuration in the future, make sure the inshellisense plugin is the last command in the file. Including commands after it may break the configuration (ex. initializing your shell plugin manager after the inshellisense plugin)
 
 ### Usage
 

package/build/commands/complete-action.js

@@ -0,0 +1,10 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import os from "node:os";
+import { getSuggestions } from "../runtime/runtime.js";
+import { Shell } from "../utils/shell.js";
+export const action = async (input) => {
+    const suggestions = await getSuggestions(input, process.cwd(), os.platform() === "win32" ? Shell.Cmd : Shell.Bash);
+    process.stdout.write(JSON.stringify(suggestions));
+    process.exit(0);
+};

package/build/commands/doctor.js

@@ -0,0 +1,11 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import { Command } from "commander";
+import { render } from "../ui/ui-doctor.js";
+const action = async () => {
+    await render();
+};
+const cmd = new Command("doctor");
+cmd.description(`checks the health of this inshellisense installation`);
+cmd.action(action);
+export default cmd;

package/build/commands/init.js

@@ -1,18 +1,24 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 import { Command } from "commander";
-import { initSupportedShells as shells, getShellConfig } from "../utils/shell.js";
+import { createShellConfigs, initSupportedShells as shells, getShellSourceCommand } from "../utils/shell.js";
 const supportedShells = shells.join(", ");
-const action = (program) => async (shell) => {
+const action = (program) => async (shell, options) => {
+    if (options.generateFullConfigs) {
+        await createShellConfigs();
+        return;
+    }
+    if (shell == null)
+        program.error(`Shell is required, supported shells: ${supportedShells}`, { exitCode: 1 });
     if (!shells.map((s) => s.valueOf()).includes(shell)) {
         program.error(`Unsupported shell: '${shell}', supported shells: ${supportedShells}`, { exitCode: 1 });
     }
-    const config = getShellConfig(shell);
-    process.stdout.write(`\n\n# ---------------- inshellisense shell plugin ----------------\n${config}`);
-    process.exit(0);
+    const config = getShellSourceCommand(shell);
+    process.stdout.write(`\n\n${config}`);
 };
 const cmd = new Command("init");
-cmd.description(`generates shell configurations for the provided shell`);
-cmd.argument("<shell>", `shell to generate configuration for, supported shells: ${supportedShells}`);
+cmd.description(`generates shell configurations and prints the source command for the specified shell`);
+cmd.argument("[shell]", `shell to generate for, supported shells: ${supportedShells}`);
+cmd.option("--generate-full-configs");
 cmd.action(action(cmd));
 export default cmd;

package/build/commands/root-action.js

@@ -0,0 +1,38 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+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";
+import { loadAliases } from "../runtime/alias.js";
+import { loadLocalSpecsSet } from "../runtime/runtime.js";
+import { program } from "./root.js";
+export const supportedShells = shells.join(", ");
+export const action = async (options) => {
+    const inISTerm = process.env.ISTERM === "1";
+    if (options.check || inISTerm) {
+        process.stdout.write(renderConfirmation(inISTerm));
+        process.exit(0);
+    }
+    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 });
+        return;
+    }
+    if (!shells.map((s) => s.valueOf()).includes(shell)) {
+        program.error(`Unsupported shell: '${shell}', supported shells: ${supportedShells}`, { exitCode: 1 });
+    }
+    if (shell == Shell.Zsh) {
+        await setupZshDotfiles();
+    }
+    else if (shell == Shell.Bash) {
+        await setupBashPreExec();
+    }
+    await loadAliases(shell);
+    await render(shell, options.test ?? false, options.login ?? false);
+};

package/build/commands/root.js

@@ -18,6 +18,7 @@ export const action = (program) => async (options) => {
         await log.enable();
     await loadConfig(program);
     await loadLocalSpecsSet();
+    log.overrideConsole();
     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 });

package/build/index.js

@@ -7,6 +7,7 @@ import complete from "./commands/complete.js";
 import uninstall from "./commands/uninstall.js";
 import init from "./commands/init.js";
 import specs from "./commands/specs/root.js";
+import doctor from "./commands/doctor.js";
 import { action, supportedShells } from "./commands/root.js";
 import { getVersion } from "./utils/version.js";
 const program = new Command();
@@ -31,4 +32,5 @@ program.addCommand(complete);
 program.addCommand(uninstall);
 program.addCommand(init);
 program.addCommand(specs);
+program.addCommand(doctor);
 program.parse();

package/build/runtime/alias.js

@@ -7,7 +7,7 @@ import { buildExecuteShellCommand } from "./utils.js";
 import os from "node:os";
 const loadedAliases = {};
 const platform = os.platform();
-const executeShellCommand = buildExecuteShellCommand(5000);
+const executeShellCommand = await 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() });
@@ -20,7 +20,7 @@ const loadBashAliases = async () => {
         .split("\n")
         .forEach((line) => {
         const [alias, ...commandSegments] = line.replace("alias ", "").replaceAll("'\\''", "'").split("=");
-        loadedAliases[alias] = parseCommand(commandSegments.join("=").slice(1, -1) + " ");
+        loadedAliases[alias] = parseCommand(commandSegments.join("=").slice(1, -1) + " ", Shell.Bash);
     });
 };
 const loadZshAliases = async () => {
@@ -34,7 +34,7 @@ const loadZshAliases = async () => {
         .split("\n")
         .forEach((line) => {
         const [alias, ...commandSegments] = line.replaceAll("'\\''", "'").split("=");
-        loadedAliases[alias] = parseCommand(commandSegments.join("=").slice(1, -1) + " ");
+        loadedAliases[alias] = parseCommand(commandSegments.join("=").slice(1, -1) + " ", Shell.Zsh);
     });
 };
 export const loadAliases = async (shell) => {

package/build/runtime/generator.js

@@ -17,7 +17,7 @@ const getGeneratorContext = (cwd) => {
 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 executeShellCommand = await buildExecuteShellCommand(scriptTimeout ?? 5000);
     const suggestions = [];
     try {
         if (script) {

package/build/runtime/parser.js

@@ -1,19 +1,48 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
+import wcwidth from "wcwidth";
+import { getShellWhitespaceEscapeChar } from "./utils.js";
 const cmdDelim = /(\|\|)|(&&)|(;)|(\|)/;
 const spaceRegex = /\s/;
-export const parseCommand = (command) => {
+export const parseCommand = (command, shell) => {
     const lastCommand = command.split(cmdDelim).at(-1)?.trimStart();
-    return lastCommand ? lex(lastCommand) : [];
+    const tokens = lastCommand ? lex(lastCommand, shell) : [];
+    return sanitizeTokens(tokens, shell);
 };
-const lex = (command) => {
+const sanitizeTokens = (cmdTokens, shell) => unwrapQuotedTokens(unescapeSpaceTokens(cmdTokens, shell), shell);
+// remove escapes around spaces
+const unescapeSpaceTokens = (cmdTokens, shell) => {
+    const escapeChar = getShellWhitespaceEscapeChar(shell);
+    return cmdTokens.map((cmdToken) => {
+        const { token, isQuoted } = cmdToken;
+        if (!isQuoted && token.includes(`${escapeChar} `)) {
+            return { ...cmdToken, token: token.replaceAll(`${escapeChar} `, " ") };
+        }
+        return cmdToken;
+    });
+};
+// need to unwrap tokens that are quoted with content after the quotes like `"hello"world`
+const unwrapQuotedTokens = (cmdTokens, shell) => {
+    const escapeChar = getShellWhitespaceEscapeChar(shell);
+    return cmdTokens.map((cmdToken) => {
+        const { token, isQuoteContinued } = cmdToken;
+        if (isQuoteContinued) {
+            const quoteChar = token[0];
+            const unquotedToken = token.replaceAll(`${escapeChar}${quoteChar}`, "\u001B").replaceAll(quoteChar, "").replaceAll("\u001B", quoteChar);
+            return { ...cmdToken, token: unquotedToken };
+        }
+        return cmdToken;
+    });
+};
+const lex = (command, shell) => {
     const tokens = [];
-    let [readingQuotedString, readingFlag, readingCmd] = [false, false, false];
+    const escapeChar = getShellWhitespaceEscapeChar(shell);
+    let [readingQuotedString, readingQuoteContinuedString, readingFlag, readingCmd] = [false, false, false, false];
     let readingIdx = 0;
     let readingQuoteChar = "";
     [...command].forEach((char, idx) => {
-        const reading = readingQuotedString || readingFlag || readingCmd;
-        if (!reading && (char === `'` || char === `"`)) {
+        const reading = readingQuotedString || readingQuoteContinuedString || readingFlag || readingCmd;
+        if (!reading && (char === `'` || char === `"` || char == "`")) {
             [readingQuotedString, readingIdx, readingQuoteChar] = [true, idx, char];
             return;
         }
@@ -25,46 +54,76 @@ const lex = (command) => {
             [readingCmd, readingIdx] = [true, idx];
             return;
         }
-        if (readingQuotedString && char === readingQuoteChar && command.at(idx - 1) !== "\\") {
+        if (readingQuotedString && char === readingQuoteChar && command.at(idx - 1) !== escapeChar && !spaceRegex.test(command.at(idx + 1) ?? " ")) {
+            readingQuotedString = false;
+            readingQuoteContinuedString = true;
+        }
+        else if (readingQuotedString && char === readingQuoteChar && command.at(idx - 1) !== escapeChar) {
             readingQuotedString = false;
             const complete = idx + 1 < command.length && spaceRegex.test(command[idx + 1]);
             tokens.push({
                 token: command.slice(readingIdx + 1, idx),
+                tokenLength: wcwidth(command.slice(readingIdx + 1, idx)) + 2,
                 complete,
                 isOption: false,
                 isQuoted: true,
             });
         }
+        else if (readingQuoteContinuedString && spaceRegex.test(char) && command.at(idx - 1) !== escapeChar) {
+            readingQuoteContinuedString = false;
+            tokens.push({
+                token: command.slice(readingIdx, idx),
+                tokenLength: wcwidth(command.slice(readingIdx, idx)),
+                complete: true,
+                isOption: false,
+                isQuoted: true,
+                isQuoteContinued: true,
+            });
+        }
         else if ((readingFlag && spaceRegex.test(char)) || char === "=") {
             readingFlag = false;
             tokens.push({
                 token: command.slice(readingIdx, idx),
+                tokenLength: wcwidth(command.slice(readingIdx, idx)),
                 complete: true,
                 isOption: true,
             });
         }
-        else if (readingCmd && spaceRegex.test(char) && command.at(idx - 1) !== "\\") {
+        else if (readingCmd && spaceRegex.test(char) && command.at(idx - 1) !== escapeChar) {
             readingCmd = false;
             tokens.push({
                 token: command.slice(readingIdx, idx),
+                tokenLength: wcwidth(command.slice(readingIdx, idx)),
                 complete: true,
                 isOption: false,
             });
         }
     });
-    const reading = readingQuotedString || readingFlag || readingCmd;
+    const reading = readingQuotedString || readingQuoteContinuedString || readingFlag || readingCmd;
     if (reading) {
         if (readingQuotedString) {
             tokens.push({
                 token: command.slice(readingIdx + 1),
+                tokenLength: wcwidth(command.slice(readingIdx + 1)) + 1,
+                complete: false,
+                isOption: false,
+                isQuoted: true,
+            });
+        }
+        else if (readingQuoteContinuedString) {
+            tokens.push({
+                token: command.slice(readingIdx),
+                tokenLength: wcwidth(command.slice(readingIdx)),
                 complete: false,
                 isOption: false,
                 isQuoted: true,
+                isQuoteContinued: true,
             });
         }
         else {
             tokens.push({
                 token: command.slice(readingIdx),
+                tokenLength: wcwidth(command.slice(readingIdx)),
                 complete: false,
                 isOption: readingFlag,
             });

package/build/runtime/runtime.js

@@ -76,7 +76,7 @@ export const loadLocalSpecsSet = async () => {
     }
 };
 export const getSuggestions = async (cmd, cwd, shell) => {
-    let activeCmd = parseCommand(cmd);
+    let activeCmd = parseCommand(cmd, shell);
     const rootToken = activeCmd.at(0);
     if (activeCmd.length === 0 || !rootToken?.complete) {
         return;
@@ -94,13 +94,10 @@ export const getSuggestions = async (cmd, cwd, shell) => {
         lastCommand.isPath = true;
         lastCommand.isPathComplete = pathyComplete;
     }
-    const result = await runSubcommand(activeCmd.slice(1), subcommand, resolvedCwd);
+    const result = await runSubcommand(activeCmd.slice(1), subcommand, resolvedCwd, shell);
     if (result == null)
         return;
-    let charactersToDrop = lastCommand?.complete ? 0 : lastCommand?.token.length ?? 0;
-    if (pathy) {
-        charactersToDrop = pathyComplete ? 0 : path.basename(lastCommand?.token ?? "").length;
-    }
+    const charactersToDrop = lastCommand?.complete ? 0 : lastCommand?.tokenLength;
     return { ...result, charactersToDrop };
 };
 export const getSpecNames = () => {
@@ -123,7 +120,7 @@ const getSubcommand = (spec) => {
     }
     return spec;
 };
-const executeShellCommand = buildExecuteShellCommand(5000);
+const executeShellCommand = await buildExecuteShellCommand(5000);
 const genSubcommand = async (command, parentCommand) => {
     if (!parentCommand.subcommands || parentCommand.subcommands.length === 0)
         return;
@@ -195,7 +192,7 @@ const getPersistentTokens = (tokens) => {
 const getArgs = (args) => {
     return args instanceof Array ? args : args != null ? [args] : [];
 };
-const runOption = async (tokens, option, subcommand, cwd, persistentOptions, acceptedTokens) => {
+const runOption = async (tokens, option, subcommand, cwd, shell, persistentOptions, acceptedTokens) => {
     if (tokens.length === 0) {
         throw new Error("invalid state reached, option expected but no tokens found");
     }
@@ -203,40 +200,40 @@ const runOption = async (tokens, option, subcommand, cwd, persistentOptions, acc
     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, cwd, persistentOptions, acceptedTokens.concat(activeToken), true, false);
+        return runArg(tokens.slice(1), args, subcommand, cwd, shell, persistentOptions, acceptedTokens.concat(activeToken), true, false);
     }
-    return runSubcommand(tokens.slice(1), subcommand, cwd, persistentOptions, acceptedTokens.concat({
+    return runSubcommand(tokens.slice(1), subcommand, cwd, shell, persistentOptions, acceptedTokens.concat({
         ...activeToken,
         isPersistent,
     }));
 };
-const runArg = async (tokens, args, subcommand, cwd, persistentOptions, acceptedTokens, fromOption, fromVariadic) => {
+const runArg = async (tokens, args, subcommand, cwd, shell, persistentOptions, acceptedTokens, fromOption, fromVariadic) => {
     if (args.length === 0) {
-        return runSubcommand(tokens, subcommand, cwd, persistentOptions, acceptedTokens, true, !fromOption);
+        return runSubcommand(tokens, subcommand, cwd, shell, persistentOptions, acceptedTokens, true, !fromOption);
     }
     else if (tokens.length === 0) {
-        return await getArgDrivenRecommendation(args, subcommand, persistentOptions, undefined, acceptedTokens, fromVariadic, cwd);
+        return await getArgDrivenRecommendation(args, subcommand, persistentOptions, undefined, acceptedTokens, fromVariadic, cwd, shell);
     }
     else if (!tokens.at(0)?.complete) {
-        return await getArgDrivenRecommendation(args, subcommand, persistentOptions, tokens[0], acceptedTokens, fromVariadic, cwd);
+        return await getArgDrivenRecommendation(args, subcommand, persistentOptions, tokens[0], acceptedTokens, fromVariadic, cwd, shell);
     }
     const activeToken = tokens[0];
     if (args.every((a) => a.isOptional)) {
         if (activeToken.isOption) {
             const option = getOption(activeToken, persistentOptions.concat(subcommand.options ?? []));
             if (option != null) {
-                return runOption(tokens, option, subcommand, cwd, persistentOptions, acceptedTokens);
+                return runOption(tokens, option, subcommand, cwd, shell, persistentOptions, acceptedTokens);
             }
             return;
         }
         const nextSubcommand = await genSubcommand(activeToken.token, subcommand);
         if (nextSubcommand != null) {
-            return runSubcommand(tokens.slice(1), nextSubcommand, cwd, persistentOptions, getPersistentTokens(acceptedTokens.concat(activeToken)));
+            return runSubcommand(tokens.slice(1), nextSubcommand, cwd, shell, persistentOptions, getPersistentTokens(acceptedTokens.concat(activeToken)));
         }
     }
     const activeArg = args[0];
     if (activeArg.isVariadic) {
-        return runArg(tokens.slice(1), args, subcommand, cwd, persistentOptions, acceptedTokens.concat(activeToken), fromOption, true);
+        return runArg(tokens.slice(1), args, subcommand, cwd, shell, persistentOptions, acceptedTokens.concat(activeToken), fromOption, true);
     }
     else if (activeArg.isCommand) {
         if (tokens.length <= 0) {
@@ -248,16 +245,16 @@ const runArg = async (tokens, args, subcommand, cwd, persistentOptions, accepted
         const subcommand = getSubcommand(spec);
         if (subcommand == null)
             return;
-        return runSubcommand(tokens.slice(1), subcommand, cwd);
+        return runSubcommand(tokens.slice(1), subcommand, cwd, shell);
     }
-    return runArg(tokens.slice(1), args.slice(1), subcommand, cwd, persistentOptions, acceptedTokens.concat(activeToken), fromOption, false);
+    return runArg(tokens.slice(1), args.slice(1), subcommand, cwd, shell, persistentOptions, acceptedTokens.concat(activeToken), fromOption, false);
 };
-const runSubcommand = async (tokens, subcommand, cwd, persistentOptions = [], acceptedTokens = [], argsDepleted = false, argsUsed = false) => {
+const runSubcommand = async (tokens, subcommand, cwd, shell, persistentOptions = [], acceptedTokens = [], argsDepleted = false, argsUsed = false) => {
     if (tokens.length === 0) {
-        return getSubcommandDrivenRecommendation(subcommand, persistentOptions, undefined, argsDepleted, argsUsed, acceptedTokens, cwd);
+        return getSubcommandDrivenRecommendation(subcommand, persistentOptions, undefined, argsDepleted, argsUsed, acceptedTokens, cwd, shell);
     }
     else if (!tokens.at(0)?.complete) {
-        return getSubcommandDrivenRecommendation(subcommand, persistentOptions, tokens[0], argsDepleted, argsUsed, acceptedTokens, cwd);
+        return getSubcommandDrivenRecommendation(subcommand, persistentOptions, tokens[0], argsDepleted, argsUsed, acceptedTokens, cwd, shell);
     }
     const activeToken = tokens[0];
     const activeArgsLength = subcommand.args instanceof Array ? subcommand.args.length : 1;
@@ -265,21 +262,21 @@ const runSubcommand = async (tokens, subcommand, cwd, persistentOptions = [], ac
     if (activeToken.isOption) {
         const option = getOption(activeToken, allOptions);
         if (option != null) {
-            return runOption(tokens, option, subcommand, cwd, persistentOptions, acceptedTokens);
+            return runOption(tokens, option, subcommand, cwd, shell, persistentOptions, acceptedTokens);
         }
         return;
     }
     const nextSubcommand = await genSubcommand(activeToken.token, subcommand);
     if (nextSubcommand != null) {
-        return runSubcommand(tokens.slice(1), nextSubcommand, cwd, getPersistentOptions(persistentOptions, subcommand.options), getPersistentTokens(acceptedTokens.concat(activeToken)));
+        return runSubcommand(tokens.slice(1), nextSubcommand, cwd, shell, getPersistentOptions(persistentOptions, subcommand.options), getPersistentTokens(acceptedTokens.concat(activeToken)));
     }
     if (activeArgsLength <= 0) {
         return; // not subcommand or option & no args exist
     }
     const args = getArgs(subcommand.args);
     if (args.length != 0) {
-        return runArg(tokens, args, subcommand, cwd, allOptions, acceptedTokens, false, false);
+        return runArg(tokens, args, subcommand, cwd, shell, allOptions, acceptedTokens, false, false);
     }
     // if the subcommand has no args specified, fallback to the subcommand and ignore this item
-    return runSubcommand(tokens.slice(1), subcommand, cwd, persistentOptions, acceptedTokens.concat(activeToken));
+    return runSubcommand(tokens.slice(1), subcommand, cwd, shell, persistentOptions, acceptedTokens.concat(activeToken));
 };

package/build/runtime/suggestion.js

@@ -4,7 +4,9 @@ import path from "node:path";
 import { runGenerator } from "./generator.js";
 import { runTemplates } from "./template.js";
 import log from "../utils/log.js";
-var SuggestionIcons;
+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";
@@ -57,7 +59,7 @@ const toSuggestion = (suggestion, name, type) => {
         allNames: suggestion.name instanceof Array ? suggestion.name : [suggestion.name],
         priority: suggestion.priority ?? 50,
         insertValue: suggestion.insertValue,
-        pathy: getPathy(suggestion.type),
+        type: suggestion.type,
     };
 };
 function filter(suggestions, filterStrategy, partialCmd, suggestionType) {
@@ -79,7 +81,7 @@ function filter(suggestions, filterStrategy, partialCmd, suggestionType) {
                             allNames: s.name,
                             priority: s.priority ?? 50,
                             insertValue: s.insertValue,
-                            pathy: getPathy(s.type),
+                            type: s.type,
                         }
                         : undefined;
                 }
@@ -91,7 +93,7 @@ function filter(suggestions, filterStrategy, partialCmd, suggestionType) {
                         allNames: [s.name],
                         priority: s.priority ?? 50,
                         insertValue: s.insertValue,
-                        pathy: getPathy(s.type),
+                        type: s.type,
                     }
                     : undefined;
             })
@@ -111,7 +113,7 @@ function filter(suggestions, filterStrategy, partialCmd, suggestionType) {
                             allNames: s.name,
                             insertValue: s.insertValue,
                             priority: s.priority ?? 50,
-                            pathy: getPathy(s.type),
+                            type: s.type,
                         }
                         : undefined;
                 }
@@ -123,7 +125,7 @@ function filter(suggestions, filterStrategy, partialCmd, suggestionType) {
                         allNames: [s.name],
                         insertValue: s.insertValue,
                         priority: s.priority ?? 50,
-                        pathy: getPathy(s.type),
+                        type: s.type,
                     }
                     : undefined;
             })
@@ -153,13 +155,15 @@ 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 getEscapedPath = (value) => {
-    return value?.replaceAll(" ", "\\ ");
-};
-function adjustPathSuggestions(suggestions, partialToken) {
-    if (partialToken == null || partialToken.isQuoted)
-        return suggestions;
-    return suggestions.map((s) => s.pathy ? { ...s, insertValue: getEscapedPath(s.insertValue), name: s.insertValue == null ? getEscapedPath(s.name) : s.name } : s);
+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));
@@ -179,7 +183,7 @@ const removeDuplicateSuggestion = (suggestions) => {
 const removeEmptySuggestion = (suggestions) => {
     return suggestions.filter((s) => s.name.length > 0);
 };
-export const getSubcommandDrivenRecommendation = async (subcommand, persistentOptions, partialToken, argsDepleted, argsFromSubcommand, acceptedTokens, cwd) => {
+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;
@@ -202,10 +206,10 @@ export const getSubcommandDrivenRecommendation = async (subcommand, persistentOp
         suggestions.push(...(await templateSuggestions(activeArg?.template, activeArg?.filterStrategy, partialCmd, cwd)));
     }
     return {
-        suggestions: removeDuplicateSuggestion(removeEmptySuggestion(removeAcceptedSuggestions(adjustPathSuggestions(suggestions.sort((a, b) => b.priority - a.priority), partialToken), acceptedTokens))),
+        suggestions: removeDuplicateSuggestion(removeEmptySuggestion(removeAcceptedSuggestions(adjustPathSuggestions(suggestions.sort((a, b) => b.priority - a.priority), partialToken, shell), acceptedTokens))),
     };
 };
-export const getArgDrivenRecommendation = async (args, subcommand, persistentOptions, partialToken, acceptedTokens, variadicArgBound, cwd) => {
+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 ?? "");
@@ -222,7 +226,7 @@ export const getArgDrivenRecommendation = async (args, subcommand, persistentOpt
         suggestions.push(...optionSuggestions(allOptions, acceptedTokens, activeArg?.filterStrategy, partialCmd));
     }
     return {
-        suggestions: removeDuplicateSuggestion(removeEmptySuggestion(removeAcceptedSuggestions(adjustPathSuggestions(suggestions.sort((a, b) => b.priority - a.priority), partialToken), 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/utils.js

@@ -3,10 +3,77 @@
 import path from "node:path";
 import { spawn } from "node:child_process";
 import fsAsync from "node:fs/promises";
-import { getPathSeperator } from "../utils/shell.js";
+import { getPathSeparator, gitBashPath, Shell } 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: { ...process.env, ...env, ISTERM: "1" } });
+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));
+};
+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 = "";
@@ -29,8 +96,9 @@ export const resolveCwd = async (cmdToken, cwd, shell) => {
     if (cmdToken == null)
         return { cwd, pathy: false, complete: false };
     const { token: rawToken, isQuoted } = cmdToken;
-    const token = !isQuoted ? rawToken.replaceAll("\\ ", " ") : rawToken;
-    const sep = getPathSeperator(shell);
+    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);

package/build/ui/ui-doctor.js

@@ -0,0 +1,41 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import chalk from "chalk";
+import { checkLegacyConfigs, checkShellConfigs } from "../utils/shell.js";
+export const render = async () => {
+    let errors = 0;
+    errors += await renderLegacyConfigIssues();
+    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;
+};

package/build/utils/config.js

@@ -125,9 +125,8 @@ export const loadConfig = async (program) => {
     });
     globalConfig.specs = { path: [`${os.homedir()}/.fig/autocomplete/build`, ...(globalConfig.specs?.path ?? [])] };
 };
-export const deleteCacheFolder = async () => {
-    const cliConfigPath = path.join(os.homedir(), cachePath);
-    if (fs.existsSync(cliConfigPath)) {
-        fs.rmSync(cliConfigPath, { recursive: true });
+export const deleteCacheFolder = () => {
+    if (fs.existsSync(cachePath)) {
+        fs.rmSync(cachePath, { recursive: true });
     }
 };

package/build/utils/log.js

@@ -1,5 +1,6 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
+/* eslint-disable @typescript-eslint/no-explicit-any */
 import os from "node:os";
 import path from "node:path";
 import fs from "node:fs";
@@ -23,8 +24,16 @@ const debug = (content) => {
         }
     });
 };
+const getLogFunction = (level) => (...data) => debug({ msg: `console.${level}`, data: data.toString() });
+const logConsole = {
+    ...console,
+    log: getLogFunction("log"),
+    error: getLogFunction("error"),
+};
+// eslint-disable-next-line no-global-assign
+const overrideConsole = () => (console = logConsole);
 export const enable = async () => {
     await reset();
     logEnabled = true;
 };
-export default { reset, debug, enable };
+export default { reset, debug, enable, overrideConsole };

package/build/utils/shell.js

@@ -8,7 +8,10 @@ import fs from "node:fs";
 import url from "node:url";
 import os from "node:os";
 import fsAsync from "node:fs/promises";
+import util from "node:util";
+import childProcess from "node:child_process";
 import log from "./log.js";
+const exec = util.promisify(childProcess.exec);
 export var Shell;
 (function (Shell) {
     Shell["Bash"] = "bash";
@@ -35,6 +38,79 @@ export const aliasSupportedShells = [Shell.Bash, Shell.Zsh];
 export const userZdotdir = process.env?.ZDOTDIR ?? os.homedir() ?? `~`;
 export const zdotdir = path.join(os.tmpdir(), `is-zsh`);
 const configFolder = ".inshellisense";
+export const checkShellConfigs = () => {
+    const shellsWithoutConfigs = [];
+    const configFolderPath = path.join(os.homedir(), configFolder);
+    for (const shell of supportedShells) {
+        const shellConfigName = getShellConfigName(shell);
+        if (shellConfigName == null)
+            continue;
+        if (!fs.existsSync(path.join(configFolderPath, shell, shellConfigName))) {
+            shellsWithoutConfigs.push(shell);
+        }
+    }
+    return shellsWithoutConfigs;
+};
+export const checkLegacyConfigs = async () => {
+    const shellsWithLegacyConfig = [];
+    for (const shell of supportedShells) {
+        const profilePath = await getProfilePath(shell);
+        if (profilePath != null && fs.existsSync(profilePath)) {
+            const profile = await fsAsync.readFile(profilePath, "utf8");
+            if (profile.includes("inshellisense shell plugin")) {
+                shellsWithLegacyConfig.push(shell);
+            }
+        }
+    }
+    return shellsWithLegacyConfig;
+};
+const getProfilePath = async (shell) => {
+    switch (shell) {
+        case Shell.Bash:
+            return path.join(os.homedir(), ".bashrc");
+        case Shell.Powershell:
+            return (await exec(`echo $profile`, { shell })).stdout.trim();
+        case Shell.Pwsh:
+            return (await exec(`echo $profile`, { shell })).stdout.trim();
+        case Shell.Zsh:
+            return path.join(os.homedir(), ".zshrc");
+        case Shell.Fish:
+            return path.join(os.homedir(), ".config", "fish", "config.fish");
+        case Shell.Xonsh:
+            return path.join(os.homedir(), ".xonshrc");
+        case Shell.Nushell:
+            return (await exec(`echo $nu.env-path`, { shell })).stdout.trim();
+    }
+};
+export const createShellConfigs = async () => {
+    const configFolderPath = path.join(os.homedir(), configFolder);
+    for (const shell of supportedShells) {
+        const shellConfigName = getShellConfigName(shell);
+        if (shellConfigName == null)
+            continue;
+        await fsAsync.mkdir(path.join(configFolderPath, shell), { recursive: true });
+        await fsAsync.writeFile(path.join(configFolderPath, shell, shellConfigName), getShellConfig(shell));
+    }
+};
+const getShellConfigName = (shell) => {
+    switch (shell) {
+        case Shell.Bash:
+            return "init.sh";
+        case Shell.Powershell:
+        case Shell.Pwsh:
+            return "init.ps1";
+        case Shell.Zsh:
+            return "init.zsh";
+        case Shell.Fish:
+            return "init.fish";
+        case Shell.Xonsh:
+            return "init.xsh";
+        case Shell.Nushell:
+            return "init.nu";
+        default:
+            return undefined;
+    }
+};
 export const setupBashPreExec = async () => {
     const shellFolderPath = path.join(path.dirname(url.fileURLToPath(import.meta.url)), "..", "..", "shell");
     const globalConfigPath = path.join(os.homedir(), configFolder);
@@ -50,7 +126,7 @@ export const setupZshDotfiles = async () => {
     await fsAsync.cp(path.join(shellFolderPath, "shellIntegration-env.zsh"), path.join(zdotdir, ".zshenv"));
     await fsAsync.cp(path.join(shellFolderPath, "shellIntegration-login.zsh"), path.join(zdotdir, ".zlogin"));
 };
-const findPareentProcess = async () => {
+const findParentProcess = async () => {
     try {
         return (await find("pid", process.ppid)).at(0);
     }
@@ -86,7 +162,7 @@ export const inferShell = async () => {
         /* empty */
     }
     // try getting shell from parent process
-    const processResult = await findPareentProcess();
+    const processResult = await findParentProcess();
     const name = processResult?.name;
     return name != null ? supportedShells.find((shell) => name.includes(shell)) : undefined;
 };
@@ -125,13 +201,43 @@ const getGitBashPaths = async () => {
     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);
+export const getPathSeparator = (shell) => (shell == Shell.Bash || shell == Shell.Xonsh || shell == Shell.Nushell ? "/" : path.sep);
+export const removePathSeparator = (dir) => {
+    return dir.endsWith("/") || dir.endsWith("\\") ? dir.slice(0, -1) : dir;
+};
+export const addPathSeparator = (dir, shell) => {
+    const pathSep = getPathSeparator(shell);
+    return dir.endsWith(pathSep) ? dir : dir + pathSep;
+};
+export const getPathDirname = (dir, shell) => {
+    const pathSep = getPathSeparator(shell);
+    return dir.endsWith(pathSep) || path.dirname(dir) == "." ? dir : addPathSeparator(path.dirname(dir), shell);
+};
 // 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;
+export const getShellSourceCommand = (shell) => {
+    switch (shell) {
+        case Shell.Bash:
+            return `[ -f ~/.inshellisense/bash/init.sh ] && source ~/.inshellisense/bash/init.sh`;
+        case Shell.Powershell:
+            return `if ( Test-Path '~/.inshellisense/powershell/init.ps1' -PathType Leaf ) { . ~/.inshellisense/powershell/init.ps1 } `;
+        case Shell.Pwsh:
+            return `if ( Test-Path '~/.inshellisense/pwsh/init.ps1' -PathType Leaf ) { . ~/.inshellisense/pwsh/init.ps1 } `;
+        case Shell.Zsh:
+            return `[[ -f ~/.inshellisense/zsh/init.zsh ]] && source ~/.inshellisense/zsh/init.zsh`;
+        case Shell.Fish:
+            return `test -f ~/.inshellisense/fish/init.fish && source ~/.inshellisense/fish/init.fish`;
+        case Shell.Xonsh:
+            return `p"~/.inshellisense/xonsh/init.xsh".exists() && source "~/.inshellisense/xonsh/init.xsh"`;
+        case Shell.Nushell:
+            return `if ( '~/.inshellisense/nu/init.nu' | path exists ) { source ~/.inshellisense/nu/init.nu } `;
+    }
+    return "";
+};
 export const getShellConfig = (shell) => {
     switch (shell) {
         case Shell.Zsh:
-            return `if [[ -z "\${ISTERM}" && $- = *i* && $- != *c* ]]; then
+            return `if [[ -z "\${ISTERM}" && $- = *i* && $- != *c* && -z "\${VSCODE_RESOLVING_ENVIRONMENT}" ]]; then
   if [[ -o login ]]; then
     is -s zsh --login ; exit
   else
@@ -139,7 +245,7 @@ export const getShellConfig = (shell) => {
   fi
 fi`;
         case Shell.Bash:
-            return `if [[ -z "\${ISTERM}" && $- = *i* && $- != *c* ]]; then
+            return `if [[ -z "\${ISTERM}" && $- = *i* && $- != *c* && -z "\${VSCODE_RESOLVING_ENVIRONMENT}" ]]; then
   shopt -q login_shell
   login_shell=$?
   if [ $login_shell -eq 0 ]; then
@@ -153,12 +259,12 @@ fi`;
             return `$__IsCommandFlag = ([Environment]::GetCommandLineArgs() | ForEach-Object { $_.contains("-Command") }) -contains $true
 $__IsNoExitFlag = ([Environment]::GetCommandLineArgs() | ForEach-Object { $_.contains("-NoExit") }) -contains $true
 $__IsInteractive = -not $__IsCommandFlag -or ($__IsCommandFlag -and $__IsNoExitFlag)
-if ([string]::IsNullOrEmpty($env:ISTERM) -and [Environment]::UserInteractive -and $__IsInteractive) {
+if ([string]::IsNullOrEmpty($env:ISTERM) -and [Environment]::UserInteractive -and $__IsInteractive -and [string]::IsNullOrEmpty($env:VSCODE_RESOLVING_ENVIRONMENT)) {
   is -s ${shell}
   Stop-Process -Id $pid
 }`;
         case Shell.Fish:
-            return `if test -z "$ISTERM" && status --is-interactive
+            return `if test -z "$ISTERM" && status --is-interactive && test -z "$VSCODE_RESOLVING_ENVIRONMENT"
   if status --is-login
     is -s fish --login ; kill %self
   else
@@ -166,13 +272,13 @@ if ([string]::IsNullOrEmpty($env:ISTERM) -and [Environment]::UserInteractive -an
   end 
 end`;
         case Shell.Xonsh:
-            return `if 'ISTERM' not in \${...} and $XONSH_INTERACTIVE:
+            return `if 'ISTERM' not in \${...} and $XONSH_INTERACTIVE and 'VSCODE_RESOLVING_ENVIRONMENT' not in \${...}:
     if $XONSH_LOGIN:
         is -s xonsh --login ; exit
     else:
         is -s xonsh ; exit`;
         case Shell.Nushell:
-            return `if "ISTERM" not-in $env and $nu.is-interactive {
+            return `if "ISTERM" not-in $env and $nu.is-interactive and "VSCODE_RESOLVING_ENVIRONMENT" not-in $env {
     if $nu.is-login { is -s nu --login ; exit } else { is -s nu ; exit }
 }`;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@microsoft/inshellisense",
-  "version": "0.0.1-rc.16",
+  "version": "0.0.1-rc.18",
   "description": "IDE style command line auto complete",
   "type": "module",
   "engines": {
@@ -13,18 +13,20 @@
   "files": [
     "build/**",
     "shell/**",
+    "scripts/**",
     "*.md",
     "LICENSE"
   ],
   "scripts": {
     "build": "tsc",
-    "dev": "node --loader ts-node/esm src/index.ts -V",
+    "dev": "node --import=tsx src/index.ts -V",
     "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js",
     "test:e2e": "tui-test",
     "lint": "eslint src/ --ext .ts,.tsx && prettier src/ --check",
     "lint:fix": "eslint src/ --ext .ts,.tsx --fix && prettier src/ --write",
-    "debug": "node --inspect --loader ts-node/esm src/index.ts -V",
-    "pre-commit": "lint-staged"
+    "debug": "node --inspect --import=tsx src/index.ts -V",
+    "pre-commit": "lint-staged",
+    "postinstall": "node ./scripts/postinstall.js"
   },
   "repository": {
     "type": "git",
@@ -40,7 +42,7 @@
   "homepage": "https://github.com/microsoft/inshellisense#readme",
   "dependencies": {
     "@homebridge/node-pty-prebuilt-multiarch": "^0.11.12",
-    "@withfig/autocomplete": "2.651.0",
+    "@withfig/autocomplete": "2.675.0",
     "@xterm/addon-unicode11": "^0.8.0",
     "@xterm/headless": "^5.5.0",
     "ajv": "^8.12.0",
@@ -77,7 +79,7 @@
     "lint-staged": "^15.2.2",
     "prettier": "3.0.3",
     "ts-jest": "^29.1.1",
-    "ts-node": "^10.9.2",
+    "tsx": "^4.19.1",
     "typescript": "^5.2.2"
   },
   "lint-staged": {

package/scripts/postinstall.js

@@ -0,0 +1,9 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+import fs from "node:fs";
+
+if (fs.existsSync("./build/commands/init.js")) {
+  const init = (await import("../build/commands/init.js")).default;
+  init.parse(["--generate-full-configs"], { from: "user" });
+}

package/shell/shellIntegration-login.zsh

@@ -1,4 +1,9 @@
 if [[ -f $USER_ZDOTDIR/.zlogin ]]; then
+	IS_ZDOTDIR=$ZDOTDIR
 	ZDOTDIR=$USER_ZDOTDIR
+
 	. $ZDOTDIR/.zlogin
-fi
+
+	USER_ZDOTDIR=$ZDOTDIR
+	ZDOTDIR=$IS_ZDOTDIR
+fi

package/shell/shellIntegration-profile.zsh

@@ -1,4 +1,9 @@
 if [[ -f $USER_ZDOTDIR/.zprofile ]]; then
+	IS_ZDOTDIR=$ZDOTDIR
 	ZDOTDIR=$USER_ZDOTDIR
+
 	. $USER_ZDOTDIR/.zprofile
-fi
+
+	USER_ZDOTDIR=$ZDOTDIR
+	ZDOTDIR=$IS_ZDOTDIR
+fi

package/shell/shellIntegration.fish

@@ -20,4 +20,4 @@ if [ "$ISTERM_TESTING" = "1" ]
 	function is_user_prompt; printf '> '; end
 end
 
-function fish_prompt; printf (__is_prompt_start); printf (is_user_prompt); printf (__is_prompt_end); end
+function fish_prompt; __is_prompt_start; is_user_prompt; __is_prompt_end; end

package/todo.md

@@ -1,4 +0,0 @@
-- [x] improve wrapping handling
-`const wrapped = line?.isWrapped || (this.#terminal.buffer.active.cursorY + this.#terminal.buffer.active.baseY) != lineY`
-`lineY < this.#terminal.rows`
-- [ ] handle paths with spaces in them on bash (ignore pwsh for now as it fails cd anyway)