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

package/shell/shellIntegration.ps1

@@ -0,0 +1,27 @@
+$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, "[$([char]0x1b)$([char]0x07)\\\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"
+    $OriginalPrompt += $Global:__IsOriginalPrompt.Invoke()
+    $Result += $OriginalPrompt
+    $Result += "$([char]0x1b)]6973;PE`a"
+
+    $Result += "$([char]0x1b)]6973;PROMPT;$(__IS-Escape-Value $OriginalPrompt)`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,37 @@
+import os
+from xonsh.main import XSH
+
+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 "\\x1b" if byte == "\x1b" else "\x0a" if byte == "\n"else "\\x07" if byte == "\x07" else byte
+            for byte in byte_list
+        ]
+    )
+
+def __is_update_cwd() -> str:
+    return f"\x1b]6973;CWD;{__is_escape_value(os.getcwd())}\x07"
+
+__is_original_prompt = $PROMPT
+def __is_report_prompt() -> str:
+    prompt = ""
+    formatted_prompt = XSH.shell.prompt_formatter(__is_original_prompt)
+    prompt = "".join([text for  _, text in XSH.shell.format_color(formatted_prompt)])
+    return f"\x1b]6973;PROMPT;{__is_escape_value(prompt)}\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
+$PROMPT_FIELDS['__is_report_prompt'] = __is_report_prompt
+if 'ISTERM_TESTING' in ${...}:
+    $PROMPT = "> "
+
+$PROMPT = "{__is_prompt_start}{__is_update_cwd}{__is_report_prompt}" + $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,69 +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 [loaded, setLoaded] = useState(false);
-    const [availableShells, setAvailableShells] = useState([]);
-    useEffect(() => {
-        availableBindings().then((bindings) => {
-            if (bindings.length == 0) {
-                exit();
-            }
-            setAvailableShells(bindings);
-            setLoaded(true);
-        });
-    }, []);
-    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));
-            }),
-            loaded
-                ? supportedShells
-                    .filter((s) => !availableShells.includes(s))
-                    .map((shell, idx) => (React.createElement(Text, { color: "gray", key: idx },
-                    "  ",
-                    shell,
-                    " (already bound)")))
-                : null,
-            !loaded ? React.createElement(Text, null, "Loading...") : null)));
-}
-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,216 +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";
-import { exec } from "node:child_process";
-import util from "node:util";
-const execAsync = util.promisify(exec);
-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, process.platform == "win32" ? Shell.Powershell : null, Shell.Pwsh, Shell.Zsh, Shell.Fish].filter((shell) => shell != null);
-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 = async () => {
-    const { stdout } = await execAsync("echo $profile", { shell: "pwsh" });
-    return stdout.trim();
-};
-const powershellConfigPath = async () => {
-    const { stdout } = await execAsync("echo $profile", { shell: "powershell" });
-    return stdout.trim();
-};
-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 powershellResolvedConfigPath = await powershellConfigPath();
-    if (process.platform == "win32") {
-        if (!fs.existsSync(powershellResolvedConfigPath)) {
-            bindings.push(Shell.Powershell);
-        }
-        else {
-            const powershellConfigContent = fsAsync.readFile(powershellResolvedConfigPath, { encoding: "utf-8" });
-            if (!(await powershellConfigContent).includes(powershellScriptCommand())) {
-                bindings.push(Shell.Powershell);
-            }
-        }
-    }
-    const pwshResolvedConfigPath = await pwshConfigPath();
-    if (!fs.existsSync(pwshResolvedConfigPath)) {
-        bindings.push(Shell.Pwsh);
-    }
-    else {
-        const pwshConfigContent = fsAsync.readFile(pwshResolvedConfigPath, { encoding: "utf-8" });
-        if (!(await pwshConfigContent).includes(pwshScriptCommand())) {
-            bindings.push(Shell.Pwsh);
-        }
-    }
-    return bindings;
-};
-export const unbindAll = async () => {
-    try {
-        const bashConfigPath = path.join(os.homedir(), ".bashrc");
-        const bashConfig = (await fsAsync.readFile(bashConfigPath)).toString();
-        if (bashConfig.includes(bashScriptCommand())) {
-            const unboundBashConfig = bashConfig.toString().replace(bashScriptCommand(), "");
-            await fsAsync.writeFile(bashConfigPath, unboundBashConfig);
-        }
-    }
-    catch {
-        /* empty */
-    }
-    try {
-        const zshConfigPath = path.join(os.homedir(), ".zshrc");
-        const zshConfig = (await fsAsync.readFile(zshConfigPath)).toString();
-        if (zshConfig.includes(zshScriptCommand())) {
-            const unboundZshConfig = zshConfig.toString().replace(zshScriptCommand(), "");
-            await fsAsync.writeFile(zshConfigPath, unboundZshConfig);
-        }
-    }
-    catch {
-        /* empty */
-    }
-    try {
-        const fishConfigPath = path.join(os.homedir(), ".config", "fish", "config.fish");
-        const fishConfig = (await fsAsync.readFile(fishConfigPath)).toString();
-        if (fishConfig.includes(fishScriptCommand())) {
-            const unboundFishConfig = fishConfig.toString().replace(fishScriptCommand(), "");
-            await fsAsync.writeFile(fishConfigPath, unboundFishConfig);
-        }
-    }
-    catch {
-        /* empty */
-    }
-    try {
-        const powershellResolvedConfigPath = await powershellConfigPath();
-        const powershellConfig = (await fsAsync.readFile(powershellResolvedConfigPath)).toString();
-        if (powershellConfig.includes(powershellScriptCommand())) {
-            const unboundPowershellConfig = powershellConfig.toString().replace(powershellScriptCommand(), "");
-            await fsAsync.writeFile(powershellResolvedConfigPath, unboundPowershellConfig);
-        }
-    }
-    catch {
-        /* empty */
-    }
-    try {
-        const pwshResolvedConfigPath = await pwshConfigPath();
-        const pwshConfig = (await fsAsync.readFile(pwshResolvedConfigPath)).toString();
-        if (pwshConfig.includes(pwshScriptCommand())) {
-            const unboundPwshConfig = pwshConfig.toString().replace(pwshScriptCommand(), "");
-            await fsAsync.writeFile(pwshResolvedConfigPath, unboundPwshConfig);
-        }
-    }
-    catch {
-        /* empty */
-    }
-};
-export const deleteConfigFolder = async () => {
-    const cliConfigPath = path.join(os.homedir(), cacheFolder);
-    if (fs.existsSync(cliConfigPath)) {
-        fs.rmSync(cliConfigPath, { recursive: true });
-    }
-};
-const safeAppendFile = async (filepath, data) => {
-    if (!fs.existsSync(filepath)) {
-        await fsAsync.mkdir(path.dirname(filepath), { recursive: true });
-        await fsAsync.writeFile(filepath, data);
-    }
-    else {
-        await fsAsync.appendFile(filepath, data);
-    }
-};
-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 safeAppendFile(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 safeAppendFile(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 fishConfigPath = path.join(os.homedir(), ".config", "fish", "config.fish");
-            await safeAppendFile(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: {
-            await safeAppendFile(await 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 safeAppendFile(await 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