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

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";
@@ -17,10 +19,10 @@ var SuggestionIcons;
     SuggestionIcons["Default"] = "\uD83D\uDCC0";
 })(SuggestionIcons || (SuggestionIcons = {}));
 const getIcon = (icon, suggestionType) => {
-    // TODO: enable fig icons once spacing is better
-    // if (icon && /[^\u0000-\u00ff]/.test(icon)) {
-    //   return icon;
-    // }
+    // eslint-disable-next-line no-control-regex
+    if (icon && /[^\u0000-\u00ff]/.test(icon)) {
+        return icon;
+    }
     switch (suggestionType) {
         case "arg":
             return SuggestionIcons.Argument;
@@ -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,17 +3,84 @@
 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: { ...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 = "";
     child.stdout.on("data", (data) => (stdout += data));
     child.stderr.on("data", (data) => (stderr += data));
     child.on("error", (err) => {
-        log.debug({ msg: "shell command failed", e: err.message });
+        log.debug({ msg: "shell command failed", command, args, e: err.message });
     });
     return new Promise((resolve) => {
         child.on("close", (code) => {
@@ -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,6 +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";
@@ -34,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);
@@ -49,6 +126,14 @@ 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 findParentProcess = async () => {
+    try {
+        return (await find("pid", process.ppid)).at(0);
+    }
+    catch (e) {
+        log.debug({ msg: `error finding parent process: ${e}` });
+    }
+};
 export const inferShell = async () => {
     // try getting shell from shell specific env variables
     if (process.env.NU_VERSION != null) {
@@ -77,7 +162,7 @@ export const inferShell = async () => {
         /* empty */
     }
     // try getting shell from parent process
-    const processResult = (await find("pid", process.ppid)).at(0);
+    const processResult = await findParentProcess();
     const name = processResult?.name;
     return name != null ? supportedShells.find((shell) => name.includes(shell)) : undefined;
 };
@@ -116,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
@@ -130,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
@@ -144,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
@@ -157,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 }
 }`;
     }