@microsoft/inshellisense 0.0.1-rc.4 → 0.0.1-rc.5

package/shell/shellIntegration.bash

@@ -0,0 +1,31 @@
+if [ -r ~/.bashrc ]; then
+    . ~/.bashrc
+fi
+if [ -r /etc/profile ]; then
+    . /etc/profile
+fi
+if [ -r ~/.bash_profile ]; then
+    . ~/.bash_profile
+elif [ -r ~/.bash_login ]; then
+    . ~/.bash_login
+elif [ -r ~/.profile ]; then
+    . ~/.profile
+fi
+
+__is_prompt_start() {
+	builtin printf '\e]6973;PS\a'
+}
+
+__is_prompt_end() {
+	builtin printf '\e]6973;PE\a'
+}
+
+__is_update_prompt() {
+	if [[ "$__is_custom_PS1" == "" || "$__is_custom_PS1" != "$PS1" ]]; then
+        __is_original_PS1=$PS1
+        __is_custom_PS1="\[$(__is_prompt_start)\]$__is_original_PS1\[$(__is_prompt_end)\]"
+        export PS1="$__is_custom_PS1"
+    fi
+}
+
+__is_update_prompt

package/shell/shellIntegration.fish

@@ -0,0 +1,6 @@
+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
+
+__is_copy_function fish_prompt is_user_prompt
+function fish_prompt; printf (__is_prompt_start); printf (is_user_prompt); printf (__is_prompt_end); end

package/shell/shellIntegration.ps1

@@ -0,0 +1,8 @@
+$Global:__IsOriginalPrompt = $function:Prompt
+
+function Global:Prompt() {
+    $Result = "$([char]0x1b)]6973;PS`a"
+    $Result += $Global:__IsOriginalPrompt.Invoke()
+    $Result += "$([char]0x1b)]6973;PE`a"
+    return $Result
+}

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/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/ui/ui-init.js

@@ -1,44 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-import React, { useState } from "react";
-import { Box, Text, render, useApp, useInput } from "ink";
-import { supportedShells } from "../utils/bindings.js";
-let uiResult = undefined;
-function UI() {
-    const { exit } = useApp();
-    const [selectionIdx, setSelectionIdx] = useState(0);
-    const [exited, setExited] = useState(false);
-    useInput(async (_, key) => {
-        if (key.upArrow) {
-            setSelectionIdx(Math.max(0, selectionIdx - 1));
-        }
-        else if (key.downArrow) {
-            setSelectionIdx(Math.min(supportedShells.length - 1, selectionIdx + 1));
-        }
-        else if (key.return) {
-            uiResult = supportedShells[selectionIdx];
-            setExited(true);
-            setTimeout(exit, 0);
-        }
-    });
-    return (React.createElement(React.Fragment, null, exited ? null : (React.createElement(Box, { flexDirection: "column" },
-        React.createElement(Box, null,
-            React.createElement(Text, { bold: true }, "Select your desired shell")),
-        React.createElement(Box, { flexDirection: "column" }, supportedShells.map((shell, idx) => {
-            if (idx == selectionIdx) {
-                return (React.createElement(Text, { color: "cyan", underline: true, key: idx },
-                    ">",
-                    " ",
-                    shell));
-            }
-            return (React.createElement(Text, { key: idx },
-                "  ",
-                shell));
-        }))))));
-}
-export const initRender = async () => {
-    uiResult = undefined;
-    const { waitUntilExit } = render(React.createElement(UI, null));
-    await waitUntilExit();
-    return uiResult;
-};

package/build/utils/bindings.js

@@ -1,236 +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 () => {
-    try {
-        const { stdout } = await execAsync("echo $profile", { shell: "pwsh" });
-        return stdout.trim();
-    }
-    catch {
-        /* empty */
-    }
-    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");
-    }
-};
-const powershellConfigPath = async () => {
-    try {
-        const { stdout } = await execAsync("echo $profile", { shell: "powershell" });
-        return stdout.trim();
-    }
-    catch {
-        /* empty */
-    }
-    return path.join(os.homedir(), "Documents", "WindowsPowershell", "Microsoft.PowerShell_profile.ps1");
-};
-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);
-        }
-    }
-    if (process.platform == "win32") {
-        const powershellResolvedConfigPath = await powershellConfigPath();
-        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