@microsoft/inshellisense 0.0.1-rc.1 → 0.0.1-rc.11

package/shell/shellIntegration.bash

@@ -0,0 +1,94 @@
+if [ -r ~/.bashrc ]; then
+    . ~/.bashrc
+fi
+
+if [ -r ~/.inshellisense/bash-preexec.sh ]; then
+    . ~/.inshellisense/bash-preexec.sh
+fi
+
+__is_prompt_start() {
+	builtin printf '\e]6973;PS\a'
+}
+
+__is_prompt_end() {
+	builtin printf '\e]6973;PE\a'
+}
+
+__is_escape_value() {
+	# Process text byte by byte, not by codepoint.
+	builtin local LC_ALL=C str="${1}" i byte token out=''
+
+	for (( i=0; i < "${#str}"; ++i )); do
+		byte="${str:$i:1}"
+
+		# Escape backslashes and semi-colons
+		if [ "$byte" = "\\" ]; then
+			token="\\\\"
+		elif [ "$byte" = ";" ]; then
+			token="\\x3b"
+		else
+			token="$byte"
+		fi
+
+		out+="$token"
+	done
+
+	builtin printf '%s\n' "${out}"
+}
+
+__is_update_cwd() {
+	builtin printf '\e]6973;CWD;%s\a' "$(__is_escape_value "$PWD")"
+}
+
+if [[ -n "${bash_preexec_imported:-}" ]]; then
+    precmd_functions+=(__is_precmd)
+fi
+
+__is_precmd() {
+	__is_update_cwd
+	__is_update_prompt
+}
+
+__is_update_prompt() {
+	if [[ "$__is_custom_PS1" == "" || "$__is_custom_PS1" != "$PS1" ]]; then
+        __is_original_PS1=$PS1
+		if [[ $ISTERM_TESTING == "1" ]]; then
+			__is_original_PS1="> "
+		fi
+        __is_custom_PS1="\[$(__is_prompt_start)\]$__is_original_PS1\[$(__is_prompt_end)\]"
+        PS1="$__is_custom_PS1"
+    fi
+}
+
+__is_prompt_cmd_original() {
+	for cmd in "${__is_original_prompt_command[@]}"; do
+		eval "${cmd:-}"
+	done
+	__is_precmd
+}
+
+# handles when a user's PROMPT_COMMAND resets their prompt after the precmd hook is triggered
+__is_prompt_cmd_safe() {
+	for cmd in "${__is_original_prompt_command[@]}"; do
+		eval "${cmd:-}"
+	done
+	if [[ "$PS1" != "$__is_safe_PS1" ]]; then 
+		__is_precmd
+		__is_safe_PS1="$PS1"
+	fi
+}
+
+__is_original_prompt_command=${PROMPT_COMMAND:-}
+if [[ -z "${bash_preexec_imported:-}" ]]; then
+	if [[ -n "${__is_original_prompt_command:-}" && "${__is_original_prompt_command:-}" != "__is_precmd" ]]; then
+		PROMPT_COMMAND=__is_prompt_cmd_original
+	else
+		PROMPT_COMMAND=__is_precmd
+	fi
+else
+	if [[ -n "${__is_original_prompt_command:-}" && "${__is_original_prompt_command:-}" != "__is_precmd" ]]; then 
+		PROMPT_COMMAND=__is_prompt_cmd_safe
+	fi
+fi
+
+__is_precmd

package/shell/shellIntegration.fish

@@ -0,0 +1,19 @@
+function __is_copy_function; functions $argv[1] | sed "s/^function $argv[1]/function $argv[2]/" | source; end
+function __is_prompt_start; printf '\e]6973;PS\a'; end
+function __is_prompt_end; printf '\e]6973;PE\a'; end
+
+function __is_escape_value
+	echo $argv \
+	| string replace --all '\\' '\\\\' \
+	| string replace --all ';' '\\x3b' \
+	;
+end
+function __is_update_cwd --on-event fish_prompt; set __is_cwd (__is_escape_value "$PWD"); printf "\e]6973;CWD;$__is_cwd\a"; end
+
+__is_copy_function fish_prompt is_user_prompt
+
+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

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.ps1

@@ -0,0 +1,24 @@
+$Global:__IsOriginalPrompt = $function:Prompt
+
+function Global:__IsTestingPrompt() {
+    return "PS > "
+}
+if ($env:ISTERM_TESTING -eq "1") {
+    $Global:__IsOriginalPrompt = $function:__IsTestingPrompt
+}
+
+function Global:__IS-Escape-Value([string]$value) {
+    [regex]::Replace($value, '[\\\n;]', { param($match)
+            -Join (
+                [System.Text.Encoding]::UTF8.GetBytes($match.Value) | ForEach-Object { '\x{0:x2}' -f $_ }
+            )
+        })
+}
+
+function Global:Prompt() {
+    $Result = "$([char]0x1b)]6973;PS`a"
+    $Result += $Global:__IsOriginalPrompt.Invoke()
+    $Result += "$([char]0x1b)]6973;PE`a"
+    $Result += if ($pwd.Provider.Name -eq 'FileSystem') { "$([char]0x1b)]6973;CWD;$(__IS-Escape-Value $pwd.ProviderPath)`a" }
+    return $Result
+}

package/shell/shellIntegration.xsh

@@ -0,0 +1,29 @@
+import os
+
+def __is_prompt_start() -> str:
+    return "\001" + "\x1b]6973;PS\x07"
+
+
+def __is_prompt_end() -> str:
+    return "\001" + "\x1b]6973;PE\x07" + "\002"
+
+
+def __is_escape_value(value: str) -> str:
+    byte_list = [bytes([byte]).decode("utf-8") for byte in list(value.encode("utf-8"))]
+    return "".join(
+        [
+            "\\x3b" if byte == ";" else "\\\\" if byte == "\\" else byte
+            for byte in byte_list
+        ]
+    )
+
+def __is_update_cwd() -> str:
+    return f"\x1b]6973;CWD;{__is_escape_value(os.getcwd())}\x07" + "\002"
+
+$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' in ${...}:
+    $PROMPT = "> "
+
+$PROMPT = "{__is_prompt_start}{__is_update_cwd}" + $PROMPT + "{__is_prompt_end}"

package/build/commands/bind.js

@@ -1,12 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-import { Command } from "commander";
-import { supportedShells } from "../utils/bindings.js";
-import { render } from "../ui/ui-bind.js";
-const action = async () => {
-    await render();
-};
-const cmd = new Command("bind");
-cmd.description(`adds keybindings to the selected shell: ${supportedShells.join(", ")}`);
-cmd.action(action);
-export default cmd;

package/build/ui/input.js

@@ -1,55 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-import React, { useState, useEffect } from "react";
-import { useInput, Text } from "ink";
-import chalk from "chalk";
-const BlinkSpeed = 530;
-const CursorColor = "#FFFFFF";
-export default function Input({ value, setValue, prompt, activeSuggestion, tabCompletionDropSize, }) {
-    const [cursorLocation, setCursorLocation] = useState(value.length);
-    const [cursorBlink, setCursorBlink] = useState(true);
-    useEffect(() => {
-        setTimeout(() => {
-            setCursorBlink(!cursorBlink);
-        }, BlinkSpeed);
-    }, [cursorBlink]);
-    // TODO: arrow key navigation shortcuts (emacs & vim modes)
-    useInput((input, key) => {
-        // TODO: handle delete better on unix systems: https://github.com/vadimdemedes/ink/issues/634
-        const windows = process.platform === "win32";
-        const backspaceKey = windows ? key.backspace : key.backspace || key.delete;
-        const deleteKey = windows ? key.delete : false;
-        if (backspaceKey) {
-            setValue([...value].slice(0, Math.max(cursorLocation - 1, 0)).join("") + [...value].slice(cursorLocation).join(""));
-            setCursorLocation(Math.max(cursorLocation - 1, 0));
-        }
-        else if (deleteKey) {
-            setValue([...value].slice(0, cursorLocation).join("") + [...value].slice(Math.min(value.length, cursorLocation + 1)).join(""));
-        }
-        else if (key.leftArrow) {
-            setCursorLocation(Math.max(cursorLocation - 1, 0));
-        }
-        else if (key.rightArrow) {
-            setCursorLocation(Math.min(cursorLocation + 1, value.length));
-        }
-        else if (key.tab) {
-            if (activeSuggestion) {
-                // TOOD: support insertValue
-                const newValue = [...value].slice(0, cursorLocation - tabCompletionDropSize).join("") + activeSuggestion.name + " ";
-                setValue(newValue);
-                setCursorLocation(newValue.length);
-            }
-        }
-        else if (input) {
-            setValue([...value].slice(0, cursorLocation).join("") + input + [...value].slice(cursorLocation).join(""));
-            setCursorLocation(cursorLocation + input.length);
-        }
-    });
-    const cursoredCommand = value + " ";
-    const cursoredText = [...cursoredCommand].slice(0, cursorLocation).join("") +
-        (cursorBlink ? chalk.bgHex(CursorColor).inverse([...cursoredCommand].at(cursorLocation)) : [...cursoredCommand].at(cursorLocation)) +
-        [...cursoredCommand].slice(cursorLocation + 1).join("");
-    return (React.createElement(Text, null,
-        prompt,
-        cursoredText));
-}

package/build/ui/suggestions.js

@@ -1,84 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-import React, { useState, useCallback, useEffect } from "react";
-import { Text, useInput, Box, measureElement } from "ink";
-import wrapAnsi from "wrap-ansi";
-const MaxSuggestions = 5;
-const SuggestionWidth = 40;
-const DescriptionWidth = 30;
-const DescriptionMaxHeight = 6;
-const BorderWidth = 2;
-const ActiveSuggestionBackgroundColor = "#7D56F4";
-function Description({ description }) {
-    wrapAnsi(description, DescriptionWidth, { hard: true });
-    if (description.length !== 0) {
-        return (React.createElement(Box, { flexDirection: "column" },
-            React.createElement(Box, { borderStyle: "single", width: DescriptionWidth },
-                React.createElement(Text, null, truncateDescription(description, DescriptionMaxHeight)))));
-    }
-}
-function truncateDescription(description, maxHeight) {
-    const wrappedText = wrapAnsi(description, DescriptionWidth - BorderWidth, {
-        trim: false,
-        hard: true,
-    });
-    const lines = wrappedText.split("\n");
-    const truncatedLines = lines.slice(0, maxHeight);
-    if (lines.length > maxHeight) {
-        truncatedLines[maxHeight - 1] = [...truncatedLines[maxHeight - 1]].slice(0, -1).join("") + "…";
-    }
-    return truncatedLines.join("\n");
-}
-function SuggestionList({ suggestions, activeSuggestionIdx }) {
-    return (React.createElement(Box, { flexDirection: "column" },
-        React.createElement(Box, { borderStyle: "single", width: SuggestionWidth, flexDirection: "column" }, suggestions
-            .map((suggestion, idx) => {
-            const bgColor = idx === activeSuggestionIdx ? ActiveSuggestionBackgroundColor : undefined;
-            return (React.createElement(Box, { key: idx },
-                React.createElement(Text, { backgroundColor: bgColor, wrap: "truncate-end" }, `${suggestion.icon} ${suggestion.name}`.padEnd(SuggestionWidth - BorderWidth, " "))));
-        })
-            .filter((node) => node !== undefined))));
-}
-export default function Suggestions({ leftPadding, setActiveSuggestion, suggestions, }) {
-    const [activeSuggestionIndex, setActiveSuggestionIndex] = useState(0);
-    const [windowWidth, setWindowWidth] = useState(500);
-    const page = Math.floor(activeSuggestionIndex / MaxSuggestions) + 1;
-    const pagedSuggestions = suggestions.filter((_, idx) => idx < page * MaxSuggestions && idx >= (page - 1) * MaxSuggestions);
-    const activePagedSuggestionIndex = activeSuggestionIndex % MaxSuggestions;
-    const activeDescription = pagedSuggestions.at(activePagedSuggestionIndex)?.description || "";
-    const wrappedPadding = leftPadding % windowWidth;
-    const maxPadding = activeDescription.length !== 0 ? windowWidth - SuggestionWidth - DescriptionWidth : windowWidth - SuggestionWidth;
-    const swapDescription = wrappedPadding > maxPadding;
-    const swappedPadding = swapDescription ? Math.max(wrappedPadding - DescriptionWidth, 0) : wrappedPadding;
-    const clampedLeftPadding = Math.min(Math.min(wrappedPadding, swappedPadding), maxPadding);
-    useEffect(() => {
-        setActiveSuggestion(suggestions[activeSuggestionIndex]);
-    }, [activeSuggestionIndex, suggestions]);
-    useEffect(() => {
-        if (suggestions.length <= activeSuggestionIndex) {
-            setActiveSuggestionIndex(Math.max(suggestions.length - 1, 0));
-        }
-    }, [suggestions]);
-    useInput((_, key) => {
-        if (key.upArrow) {
-            setActiveSuggestionIndex(Math.max(0, activeSuggestionIndex - 1));
-        }
-        if (key.downArrow) {
-            setActiveSuggestionIndex(Math.min(activeSuggestionIndex + 1, suggestions.length - 1));
-        }
-    });
-    const measureRef = useCallback((node) => {
-        if (node !== null) {
-            const { width } = measureElement(node);
-            setWindowWidth(width);
-        }
-    }, []);
-    if (suggestions.length === 0)
-        return React.createElement(React.Fragment, null);
-    return (React.createElement(Box, { ref: measureRef },
-        React.createElement(Box, { paddingLeft: clampedLeftPadding }, swapDescription ? (React.createElement(React.Fragment, null,
-            React.createElement(Description, { description: activeDescription }),
-            React.createElement(SuggestionList, { suggestions: pagedSuggestions, activeSuggestionIdx: activePagedSuggestionIndex }))) : (React.createElement(React.Fragment, null,
-            React.createElement(SuggestionList, { suggestions: pagedSuggestions, activeSuggestionIdx: activePagedSuggestionIndex }),
-            React.createElement(Description, { description: activeDescription }))))));
-}

package/build/ui/ui-bind.js

@@ -1,64 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-import React, { useEffect, useState } from "react";
-import { Box, Text, render as inkRender, useInput, useApp } from "ink";
-import chalk from "chalk";
-import { availableBindings, bind, supportedShells } from "../utils/bindings.js";
-let uiResult = "";
-function UI() {
-    const { exit } = useApp();
-    const [selectionIdx, setSelectionIdx] = useState(0);
-    const [availableShells, setAvailableShells] = useState([]);
-    useEffect(() => {
-        availableBindings().then((bindings) => {
-            if (bindings.length == 0) {
-                exit();
-            }
-            setAvailableShells(bindings);
-        });
-    }, []);
-    useInput(async (_, key) => {
-        if (key.upArrow) {
-            setSelectionIdx(Math.max(0, selectionIdx - 1));
-        }
-        else if (key.downArrow) {
-            setSelectionIdx(Math.min(availableShells.length - 1, selectionIdx + 1));
-        }
-        else if (key.return) {
-            await bind(availableShells[selectionIdx]);
-            uiResult = availableShells[selectionIdx];
-            exit();
-        }
-    });
-    return (React.createElement(Box, { flexDirection: "column" },
-        React.createElement(Box, null,
-            React.createElement(Text, { bold: true }, "Select your desired shell for keybinding creation")),
-        React.createElement(Box, { flexDirection: "column" },
-            availableShells.map((shell, idx) => {
-                if (idx == selectionIdx) {
-                    return (React.createElement(Text, { color: "cyan", underline: true, key: idx },
-                        ">",
-                        " ",
-                        shell));
-                }
-                return (React.createElement(Text, { key: idx },
-                    "  ",
-                    shell));
-            }),
-            supportedShells
-                .filter((s) => !availableShells.includes(s))
-                .map((shell, idx) => (React.createElement(Text, { color: "gray", key: idx },
-                "  ",
-                shell,
-                " (already bound)"))))));
-}
-export const render = async () => {
-    const { waitUntilExit } = inkRender(React.createElement(UI, null));
-    await waitUntilExit();
-    if (uiResult.length !== 0) {
-        process.stdout.write("\n" + chalk.green("✓") + " successfully created new bindings \n");
-    }
-    else {
-        process.stdout.write("\n");
-    }
-};

package/build/utils/bindings.js

@@ -1,144 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-import os from "node:os";
-import path from "node:path";
-import fsAsync from "node:fs/promises";
-import fs from "node:fs";
-import process from "node:process";
-import url from "node:url";
-const __filename = url.fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-const cacheFolder = ".inshellisense";
-export var Shell;
-(function (Shell) {
-    Shell["Bash"] = "bash";
-    Shell["Powershell"] = "powershell";
-    Shell["Pwsh"] = "pwsh";
-    Shell["Zsh"] = "zsh";
-    Shell["Fish"] = "fish";
-})(Shell || (Shell = {}));
-export const supportedShells = [Shell.Bash, Shell.Powershell, Shell.Pwsh, Shell.Zsh, Shell.Fish];
-const bashScriptCommand = () => {
-    return `[ -f ~/${cacheFolder}/key-bindings.bash ] && source ~/${cacheFolder}/key-bindings.bash`;
-};
-const zshScriptCommand = () => {
-    return `[ -f ~/${cacheFolder}/key-bindings.zsh ] && source ~/${cacheFolder}/key-bindings.zsh`;
-};
-const fishScriptCommand = () => {
-    return `[ -f ~/${cacheFolder}/key-bindings.fish ] && source ~/${cacheFolder}/key-bindings.fish`;
-};
-const powershellScriptCommand = () => {
-    const bindingsPath = path.join(os.homedir(), cacheFolder, "key-bindings-powershell.ps1");
-    return `if(Test-Path '${bindingsPath}' -PathType Leaf){. ${bindingsPath}}`;
-};
-const pwshScriptCommand = () => {
-    const bindingsPath = path.join(os.homedir(), cacheFolder, "key-bindings-pwsh.ps1");
-    return `if(Test-Path '${bindingsPath}' -PathType Leaf){. ${bindingsPath}}`;
-};
-const pwshConfigPath = () => {
-    switch (process.platform) {
-        case "win32":
-            return path.join(os.homedir(), "Documents", "Powershell", "Microsoft.PowerShell_profile.ps1");
-        case "linux":
-        case "darwin":
-            return path.join(os.homedir(), ".config", "powershell", "Microsoft.PowerShell_profile.ps1");
-        default:
-            throw new Error("Unsupported platform");
-    }
-};
-export const availableBindings = async () => {
-    const cliConfigPath = path.join(os.homedir(), cacheFolder);
-    if (!fs.existsSync(cliConfigPath)) {
-        await fsAsync.mkdir(cliConfigPath);
-    }
-    const bindings = [];
-    const bashConfigPath = path.join(os.homedir(), ".bashrc");
-    if (!fs.existsSync(bashConfigPath)) {
-        bindings.push(Shell.Bash);
-    }
-    else {
-        const bashConfigContent = fsAsync.readFile(bashConfigPath, { encoding: "utf-8" });
-        if (!(await bashConfigContent).includes(bashScriptCommand())) {
-            bindings.push(Shell.Bash);
-        }
-    }
-    const zshConfigPath = path.join(os.homedir(), ".zshrc");
-    if (!fs.existsSync(zshConfigPath)) {
-        bindings.push(Shell.Zsh);
-    }
-    else {
-        const zshConfigContent = fsAsync.readFile(zshConfigPath, { encoding: "utf-8" });
-        if (!(await zshConfigContent).includes(zshScriptCommand())) {
-            bindings.push(Shell.Zsh);
-        }
-    }
-    const fishConfigPath = path.join(os.homedir(), ".config", "fish", "config.fish");
-    if (!fs.existsSync(fishConfigPath)) {
-        bindings.push(Shell.Fish);
-    }
-    else {
-        const fishConfigContent = fsAsync.readFile(fishConfigPath, { encoding: "utf-8" });
-        if (!(await fishConfigContent).includes(fishScriptCommand())) {
-            bindings.push(Shell.Fish);
-        }
-    }
-    const powershellConfigPath = path.join(os.homedir(), "Documents", "WindowsPowershell", "Microsoft.PowerShell_profile.ps1");
-    if (!fs.existsSync(powershellConfigPath)) {
-        bindings.push(Shell.Powershell);
-    }
-    else {
-        const powershellConfigContent = fsAsync.readFile(powershellConfigPath, { encoding: "utf-8" });
-        if (!(await powershellConfigContent).includes(powershellScriptCommand())) {
-            bindings.push(Shell.Powershell);
-        }
-    }
-    if (!fs.existsSync(pwshConfigPath())) {
-        bindings.push(Shell.Pwsh);
-    }
-    else {
-        const pwshConfigContent = fsAsync.readFile(pwshConfigPath(), { encoding: "utf-8" });
-        if (!(await pwshConfigContent).includes(pwshScriptCommand())) {
-            bindings.push(Shell.Pwsh);
-        }
-    }
-    return bindings;
-};
-export const bind = async (shell) => {
-    const cliConfigPath = path.join(os.homedir(), cacheFolder);
-    if (!fs.existsSync(cliConfigPath)) {
-        await fsAsync.mkdir(cliConfigPath);
-    }
-    switch (shell) {
-        case Shell.Bash: {
-            const bashConfigPath = path.join(os.homedir(), ".bashrc");
-            await fsAsync.appendFile(bashConfigPath, `\n${bashScriptCommand()}`);
-            await fsAsync.copyFile(path.join(__dirname, "..", "..", "shell", "key-bindings.bash"), path.join(os.homedir(), cacheFolder, "key-bindings.bash"));
-            break;
-        }
-        case Shell.Zsh: {
-            const zshConfigPath = path.join(os.homedir(), ".zshrc");
-            await fsAsync.appendFile(zshConfigPath, `\n${zshScriptCommand()}`);
-            await fsAsync.copyFile(path.join(__dirname, "..", "..", "shell", "key-bindings.zsh"), path.join(os.homedir(), cacheFolder, "key-bindings.zsh"));
-            break;
-        }
-        case Shell.Fish: {
-            const fishConfigDirectory = path.join(os.homedir(), ".config", "fish");
-            const fishConfigPath = path.join(fishConfigDirectory, "config.fish");
-            await fsAsync.mkdir(fishConfigDirectory, { recursive: true });
-            await fsAsync.appendFile(fishConfigPath, `\n${fishScriptCommand()}`);
-            await fsAsync.copyFile(path.join(__dirname, "..", "..", "shell", "key-bindings.fish"), path.join(os.homedir(), cacheFolder, "key-bindings.fish"));
-            break;
-        }
-        case Shell.Powershell: {
-            const powershellConfigPath = path.join(os.homedir(), "Documents", "WindowsPowershell", "Microsoft.PowerShell_profile.ps1");
-            await fsAsync.appendFile(powershellConfigPath, `\n${powershellScriptCommand()}`);
-            await fsAsync.copyFile(path.join(__dirname, "..", "..", "shell", "key-bindings-powershell.ps1"), path.join(os.homedir(), cacheFolder, "key-bindings-powershell.ps1"));
-            break;
-        }
-        case Shell.Pwsh: {
-            await fsAsync.appendFile(pwshConfigPath(), `\n${pwshScriptCommand()}`);
-            await fsAsync.copyFile(path.join(__dirname, "..", "..", "shell", "key-bindings-pwsh.ps1"), path.join(os.homedir(), cacheFolder, "key-bindings-pwsh.ps1"));
-            break;
-        }
-    }
-};

package/build/utils/cache.js

@@ -1,21 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-import os from "node:os";
-import path from "node:path";
-import fsAsync from "node:fs/promises";
-import fs from "node:fs";
-const cacheFolder = ".inshellisense";
-const folderPath = path.join(os.homedir(), cacheFolder);
-const cachePath = path.join(os.homedir(), cacheFolder, "inshellisense.cache");
-export const saveCommand = async (command) => {
-    if (!fs.existsSync(folderPath)) {
-        await fsAsync.mkdir(folderPath);
-    }
-    await fsAsync.writeFile(cachePath, command.map((c, idx) => `${idx.toString().padStart(5)}  ${c}`).join("\n"));
-};
-export const loadCommand = async () => {
-    if (!fs.existsSync(folderPath)) {
-        await fsAsync.mkdir(folderPath);
-    }
-    return fsAsync.readFile(cachePath, { encoding: "utf-8" });
-};

package/shell/key-bindings-powershell.ps1

@@ -1,27 +0,0 @@
-Set-PSReadLineKeyHandler -Chord 'Ctrl+a' -ScriptBlock {
-    $command = $null
-    [Microsoft.PowerShell.PSConsoleReadLine]::GetBufferState([ref]$command, [ref]$null)
-
-    $oldPrompt = $function:prompt
-    function prompt { "`r" }
-    [Microsoft.PowerShell.PSConsoleReadLine]::InvokePrompt()
-    $prompt = $oldPrompt
-
-    [Microsoft.PowerShell.PSConsoleReadLine]::ClearKillRing()
-    [Microsoft.PowerShell.PSConsoleReadLine]::BeginningOfLine()
-    [Microsoft.PowerShell.PSConsoleReadLine]::KillLine()
-    [Microsoft.PowerShell.PSConsoleReadLine]::AcceptLine()
-
-    $inshellisense = "$env:USERPROFILE\AppData\Roaming\npm\node_modules\@microsoft\inshellisense\build\index.js"
-    if ($command) {
-        Start-Process -NoNewWindow -Wait "node" "$inshellisense -c $command -s powershell"
-    }
-    else {
-        Start-Process -NoNewWindow -Wait "node" "$inshellisense -s powershell"
-    }
-
-    $executedCommand = node $inshellisense --history
-    if ($executedCommand) {
-        [Microsoft.PowerShell.PSConsoleReadLine]::AddToHistory($executedCommand)
-    }
-}

package/shell/key-bindings-pwsh.ps1

@@ -1,27 +0,0 @@
-Set-PSReadLineKeyHandler -Chord 'Ctrl+a' -ScriptBlock {
-    $command = $null
-    [Microsoft.PowerShell.PSConsoleReadLine]::GetBufferState([ref]$command, [ref]$null)
-
-    $oldPrompt = $function:prompt
-    function prompt { "`r" }
-    [Microsoft.PowerShell.PSConsoleReadLine]::InvokePrompt()
-    $prompt = $oldPrompt
-
-    [Microsoft.PowerShell.PSConsoleReadLine]::ClearKillRing()
-    [Microsoft.PowerShell.PSConsoleReadLine]::BeginningOfLine()
-    [Microsoft.PowerShell.PSConsoleReadLine]::KillLine()
-
-    $inshellisense = "$env:USERPROFILE\AppData\Roaming\npm\node_modules\@microsoft\inshellisense\build\index.js"
-    if ($command) {
-        Start-Process -NoNewWindow -Wait "node" "$inshellisense -c $command -s pwsh"
-    }
-    else {
-        Start-Process -NoNewWindow -Wait "node" "$inshellisense -s pwsh"
-    }
-
-    $executedCommand = node $inshellisense --history
-    if ($executedCommand) {
-        [Microsoft.PowerShell.PSConsoleReadLine]::AddToHistory($executedCommand)
-    }
-    [Microsoft.PowerShell.PSConsoleReadLine]::AcceptLine()
-}

package/shell/key-bindings.bash

@@ -1,7 +0,0 @@
-__inshellisense__() {
-    inshellisense -c "$READLINE_LINE" -s bash
-    history -s $(inshellisense --history)
-    READLINE_LINE=
-}
-
-bind -x '"\C-a": __inshellisense__'

package/shell/key-bindings.fish

@@ -1,8 +0,0 @@
-function inshellisense-widget -d "Activate autocomplete"
-    inshellisense -c (commandline -b) -s fish
-    commandline -r ''
-    commandline -f repaint
-    # TODO: add support for history insertion
-end
-
-bind \ca inshellisense-widget

package/shell/key-bindings.zsh

@@ -1,10 +0,0 @@
-__inshellisense__() {
-    input=$LBUFFER
-    LBUFFER=
-    inshellisense -c "$input" -s zsh < $TTY
-    print -s $(inshellisense --history)
-    zle reset-prompt
-}
-
-zle     -N   __inshellisense __inshellisense__
-bindkey '^A' __inshellisense