@microsoft/inshellisense 0.0.1-rc.1

package/build/runtime/suggestion.js

@@ -0,0 +1,184 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import { runGenerator } from "./generator.js";
+import { runTemplates } from "./template.js";
+var SuggestionIcons;
+(function (SuggestionIcons) {
+    SuggestionIcons["File"] = "\uD83D\uDCC4";
+    SuggestionIcons["Folder"] = "\uD83D\uDCC1";
+    SuggestionIcons["Subcommand"] = "\uD83D\uDCE6";
+    SuggestionIcons["Option"] = "\uD83D\uDD17";
+    SuggestionIcons["Argument"] = "\uD83D\uDCB2";
+    SuggestionIcons["Mixin"] = "\uD83C\uDFDD\uFE0F";
+    SuggestionIcons["Shortcut"] = "\uD83D\uDD25";
+    SuggestionIcons["Special"] = "\u2B50";
+    SuggestionIcons["Default"] = "\uD83D\uDCC0";
+})(SuggestionIcons || (SuggestionIcons = {}));
+const getIcon = (suggestionType) => {
+    switch (suggestionType) {
+        case "arg":
+            return SuggestionIcons.Argument;
+        case "file":
+            return SuggestionIcons.File;
+        case "folder":
+            return SuggestionIcons.Folder;
+        case "option":
+            return SuggestionIcons.Option;
+        case "subcommand":
+            return SuggestionIcons.Subcommand;
+        case "mixin":
+            return SuggestionIcons.Mixin;
+        case "shortcut":
+            return SuggestionIcons.Shortcut;
+        case "special":
+            return SuggestionIcons.Special;
+    }
+    return SuggestionIcons.Default;
+};
+const getLong = (suggestion) => {
+    return suggestion instanceof Array ? suggestion.reduce((p, c) => (p.length > c.length ? p : c)) : suggestion;
+};
+const toSuggestion = (suggestion, name, type) => {
+    if (suggestion.name == null)
+        return;
+    return {
+        name: name ?? getLong(suggestion.name),
+        description: suggestion.description,
+        icon: getIcon(type ?? suggestion.type),
+        allNames: suggestion.name instanceof Array ? suggestion.name : [suggestion.name],
+        priority: suggestion.priority ?? 50,
+        insertValue: suggestion.insertValue,
+    };
+};
+function filter(suggestions, filterStrategy, partialCmd, suggestionType) {
+    if (!partialCmd)
+        return suggestions.map((s) => toSuggestion(s, undefined, suggestionType)).filter((s) => s != null);
+    switch (filterStrategy) {
+        case "fuzzy":
+            return suggestions
+                .map((s) => {
+                if (s.name == null)
+                    return;
+                if (s.name instanceof Array) {
+                    const matchedName = s.name.find((n) => n.toLowerCase().includes(partialCmd.toLowerCase()));
+                    return matchedName != null
+                        ? {
+                            name: matchedName,
+                            description: s.description,
+                            icon: getIcon(s.type ?? suggestionType),
+                            allNames: s.name,
+                            priority: s.priority ?? 50,
+                            insertValue: s.insertValue,
+                        }
+                        : undefined;
+                }
+                return s.name.toLowerCase().includes(partialCmd.toLowerCase())
+                    ? {
+                        name: s.name,
+                        description: s.description,
+                        icon: getIcon(s.type ?? suggestionType),
+                        allNames: [s.name],
+                        priority: s.priority ?? 50,
+                        insertValue: s.insertValue,
+                    }
+                    : undefined;
+            })
+                .filter((s) => s != null);
+        default:
+            return suggestions
+                .map((s) => {
+                if (s.name == null)
+                    return;
+                if (s.name instanceof Array) {
+                    const matchedName = s.name.find((n) => n.toLowerCase().startsWith(partialCmd.toLowerCase()));
+                    return matchedName != null
+                        ? {
+                            name: matchedName,
+                            description: s.description,
+                            icon: getIcon(s.type ?? suggestionType),
+                            allNames: s.name,
+                            insertValue: s.insertValue,
+                            priority: s.priority ?? 50,
+                        }
+                        : undefined;
+                }
+                return s.name.toLowerCase().startsWith(partialCmd.toLowerCase())
+                    ? {
+                        name: s.name,
+                        description: s.description,
+                        icon: getIcon(s.type ?? suggestionType),
+                        allNames: [s.name],
+                        insertValue: s.insertValue,
+                        priority: s.priority ?? 50,
+                    }
+                    : undefined;
+            })
+                .filter((s) => s != null);
+    }
+}
+const generatorSuggestions = async (generator, acceptedTokens, filterStrategy, partialCmd) => {
+    const generators = generator instanceof Array ? generator : generator ? [generator] : [];
+    const tokens = acceptedTokens.map((t) => t.token);
+    const suggestions = (await Promise.all(generators.map((gen) => runGenerator(gen, tokens)))).flat();
+    return filter(suggestions, filterStrategy, partialCmd, undefined);
+};
+const templateSuggestions = async (templates, filterStrategy, partialCmd) => {
+    return filter(await runTemplates(templates ?? []), filterStrategy, partialCmd, undefined);
+};
+const suggestionSuggestions = (suggestions, filterStrategy, partialCmd) => {
+    const cleanedSuggestions = suggestions?.map((s) => (typeof s === "string" ? { name: s } : s)) ?? [];
+    return filter(cleanedSuggestions ?? [], filterStrategy, partialCmd, undefined);
+};
+const subcommandSuggestions = (subcommands, filterStrategy, partialCmd) => {
+    return filter(subcommands ?? [], filterStrategy, partialCmd, "subcommand");
+};
+const optionSuggestions = (options, acceptedTokens, filterStrategy, partialCmd) => {
+    const usedOptions = new Set(acceptedTokens.filter((t) => t.isOption).map((t) => t.token));
+    const validOptions = options?.filter((o) => o.exclusiveOn?.every((exclusiveOption) => !usedOptions.has(exclusiveOption)) ?? true);
+    return filter(validOptions ?? [], filterStrategy, partialCmd, "option");
+};
+const removeDuplicateSuggestions = (suggestions, acceptedTokens) => {
+    const seen = new Set(acceptedTokens.map((t) => t.token));
+    return suggestions.filter((s) => s.allNames.every((n) => !seen.has(n)));
+};
+const removeEmptySuggestion = (suggestions) => {
+    return suggestions.filter((s) => s.name.length > 0);
+};
+export const getSubcommandDrivenRecommendation = async (subcommand, persistentOptions, partialCmd, argsDepleted, argsFromSubcommand, acceptedTokens) => {
+    if (argsDepleted && argsFromSubcommand) {
+        return;
+    }
+    const suggestions = [];
+    const argLength = subcommand.args instanceof Array ? subcommand.args.length : subcommand.args ? 1 : 0;
+    const allOptions = persistentOptions.concat(subcommand.options ?? []);
+    if (!argsFromSubcommand) {
+        suggestions.push(...subcommandSuggestions(subcommand.subcommands, subcommand.filterStrategy, partialCmd));
+        suggestions.push(...optionSuggestions(allOptions, acceptedTokens, subcommand.filterStrategy, partialCmd));
+    }
+    if (argLength != 0) {
+        const activeArg = subcommand.args instanceof Array ? subcommand.args[0] : subcommand.args;
+        suggestions.push(...(await generatorSuggestions(activeArg?.generators, acceptedTokens, activeArg?.filterStrategy, partialCmd)));
+        suggestions.push(...suggestionSuggestions(activeArg?.suggestions, activeArg?.filterStrategy, partialCmd));
+        suggestions.push(...(await templateSuggestions(activeArg?.template, activeArg?.filterStrategy, partialCmd)));
+    }
+    return {
+        suggestions: removeEmptySuggestion(removeDuplicateSuggestions(suggestions.sort((a, b) => b.priority - a.priority), acceptedTokens)),
+    };
+};
+export const getArgDrivenRecommendation = async (args, subcommand, persistentOptions, partialCmd, acceptedTokens, variadicArgBound) => {
+    const activeArg = args[0];
+    const allOptions = persistentOptions.concat(subcommand.options ?? []);
+    const suggestions = [
+        ...(await generatorSuggestions(args[0].generators, acceptedTokens, activeArg?.filterStrategy, partialCmd)),
+        ...suggestionSuggestions(args[0].suggestions, activeArg?.filterStrategy, partialCmd),
+        ...(await templateSuggestions(args[0].template, activeArg?.filterStrategy, partialCmd)),
+    ];
+    if ((activeArg.isOptional && !activeArg.isVariadic) || (activeArg.isVariadic && activeArg.isOptional && !variadicArgBound)) {
+        suggestions.push(...subcommandSuggestions(subcommand.subcommands, activeArg?.filterStrategy, partialCmd));
+        suggestions.push(...optionSuggestions(allOptions, acceptedTokens, activeArg?.filterStrategy, partialCmd));
+    }
+    return {
+        suggestions: removeEmptySuggestion(removeDuplicateSuggestions(suggestions.sort((a, b) => b.priority - a.priority), acceptedTokens)),
+        argumentDescription: activeArg.description ?? activeArg.name,
+    };
+};

package/build/runtime/template.js

@@ -0,0 +1,35 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import fsAsync from "fs/promises";
+import process from "node:process";
+const filepathsTemplate = async () => {
+    const files = await fsAsync.readdir(process.cwd(), { withFileTypes: true });
+    return files.filter((f) => f.isFile() || f.isDirectory()).map((f) => ({ name: f.name, priority: 90 }));
+};
+const foldersTemplate = async () => {
+    const files = await fsAsync.readdir(process.cwd(), { withFileTypes: true });
+    return files.filter((f) => f.isDirectory()).map((f) => ({ name: f.name, priority: 90 }));
+};
+// TODO: implement history template
+const historyTemplate = () => {
+    return [];
+};
+// TODO: implement help template
+const helpTemplate = () => {
+    return [];
+};
+export const runTemplates = async (template) => {
+    const templates = template instanceof Array ? template : [template];
+    return (await Promise.all(templates.map(async (t) => {
+        switch (t) {
+            case "filepaths":
+                return await filepathsTemplate();
+            case "folders":
+                return await foldersTemplate();
+            case "history":
+                return historyTemplate();
+            case "help":
+                return helpTemplate();
+        }
+    }))).flat();
+};

package/build/runtime/utils.js

@@ -0,0 +1,22 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import { exec, spawn } from "node:child_process";
+export const buildExecuteShellCommand = (timeout) => 
+// eslint-disable-next-line @typescript-eslint/no-unused-vars -- TODO: use cwd in the future
+async (command, cwd) => {
+    return new Promise((resolve) => {
+        exec(command, { timeout }, (_, stdout, stderr) => {
+            resolve(stdout || stderr);
+        });
+    });
+};
+export const executeShellCommandTTY = async (shell, command) => {
+    const child = spawn(shell, ["-c", command.trim()], { stdio: "inherit" });
+    return new Promise((resolve) => {
+        child.on("close", (code) => {
+            resolve({
+                code,
+            });
+        });
+    });
+};

package/build/ui/input.js

@@ -0,0 +1,55 @@
+// 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

@@ -0,0 +1,84 @@
+// 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

@@ -0,0 +1,64 @@
+// 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/ui/ui-root.js

@@ -0,0 +1,71 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import React, { useCallback, useEffect, useState } from "react";
+import { Text, Box, render as inkRender, measureElement, useInput, useApp } from "ink";
+import wrapAnsi from "wrap-ansi";
+import { getSuggestions } from "../runtime/runtime.js";
+import Suggestions from "./suggestions.js";
+import Input from "./input.js";
+const Prompt = "> ";
+let uiResult = undefined;
+function UI({ startingCommand }) {
+    const { exit } = useApp();
+    const [isExiting, setIsExiting] = useState(false);
+    const [command, setCommand] = useState(startingCommand);
+    const [activeSuggestion, setActiveSuggestion] = useState();
+    const [tabCompletionDropSize, setTabCompletionDropSize] = useState(0);
+    const [suggestions, setSuggestions] = useState([]);
+    const [windowWidth, setWindowWidth] = useState(500);
+    const leftPadding = getLeftPadding(windowWidth, command);
+    const measureRef = useCallback((node) => {
+        if (node !== null) {
+            const { width } = measureElement(node);
+            setWindowWidth(width);
+        }
+    }, []);
+    useInput((input, key) => {
+        if (key.ctrl && input.toLowerCase() == "d") {
+            uiResult = undefined;
+            exit();
+        }
+        if (key.return) {
+            setIsExiting(true);
+        }
+    });
+    useEffect(() => {
+        if (isExiting) {
+            uiResult = command;
+            exit();
+        }
+    }, [isExiting]);
+    useEffect(() => {
+        getSuggestions(command).then((suggestions) => {
+            setSuggestions(suggestions?.suggestions ?? []);
+            setTabCompletionDropSize(suggestions?.charactersToDrop ?? 0);
+        });
+    }, [command]);
+    if (isExiting) {
+        return (React.createElement(Text, null,
+            Prompt,
+            command));
+    }
+    return (React.createElement(Box, { flexDirection: "column", ref: measureRef },
+        React.createElement(Box, null,
+            React.createElement(Text, null,
+                React.createElement(Input, { value: command, setValue: setCommand, prompt: Prompt, activeSuggestion: activeSuggestion, tabCompletionDropSize: tabCompletionDropSize }))),
+        React.createElement(Suggestions, { leftPadding: leftPadding, setActiveSuggestion: setActiveSuggestion, suggestions: suggestions })));
+}
+export const render = async (command) => {
+    uiResult = undefined;
+    const { waitUntilExit } = inkRender(React.createElement(UI, { startingCommand: command ?? "" }));
+    await waitUntilExit();
+    return uiResult;
+};
+function getLeftPadding(windowWidth, command) {
+    const wrappedText = wrapAnsi(command + "", windowWidth, {
+        trim: false,
+        hard: true,
+    });
+    const lines = wrappedText.split("\n");
+    return (lines.length - 1) * windowWidth + lines[lines.length - 1].length + Prompt.length;
+}

package/build/utils/bindings.js

@@ -0,0 +1,144 @@
+// 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;
+        }
+    }
+};