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

package/build/ui/suggestionManager.js

@@ -0,0 +1,139 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import { getSuggestions } from "../runtime/runtime.js";
+import { renderBox, truncateText, truncateMultilineText } from "./utils.js";
+import ansi from "ansi-escapes";
+import chalk from "chalk";
+import { parseKeystroke } from "../utils/ansi.js";
+const maxSuggestions = 5;
+const suggestionWidth = 40;
+const descriptionWidth = 30;
+const descriptionHeight = 5;
+const borderWidth = 2;
+const activeSuggestionBackgroundColor = "#7D56F4";
+export const MAX_LINES = borderWidth + Math.max(maxSuggestions, descriptionHeight);
+export class SuggestionManager {
+    #term;
+    #command;
+    #activeSuggestionIdx;
+    #suggestBlob;
+    #shell;
+    constructor(terminal, shell) {
+        this.#term = terminal;
+        this.#suggestBlob = { suggestions: [] };
+        this.#command = "";
+        this.#activeSuggestionIdx = 0;
+        this.#shell = shell;
+    }
+    async _loadSuggestions() {
+        const commandText = this.#term.getCommandState().commandText;
+        if (!commandText) {
+            this.#suggestBlob = undefined;
+            return;
+        }
+        if (commandText == this.#command) {
+            return;
+        }
+        this.#command = commandText;
+        const suggestionBlob = await getSuggestions(commandText, this.#term.cwd, this.#shell);
+        this.#suggestBlob = suggestionBlob;
+    }
+    _renderArgumentDescription(description, x) {
+        if (!description)
+            return "";
+        return renderBox([truncateText(description, descriptionWidth - borderWidth)], descriptionWidth, x);
+    }
+    _renderDescription(description, x) {
+        if (!description)
+            return "";
+        return renderBox(truncateMultilineText(description, descriptionWidth - borderWidth, descriptionHeight), descriptionWidth, x);
+    }
+    _descriptionRows(description) {
+        if (!description)
+            return 0;
+        return truncateMultilineText(description, descriptionWidth - borderWidth, descriptionHeight).length;
+    }
+    _renderSuggestions(suggestions, activeSuggestionIdx, x) {
+        return renderBox(suggestions.map((suggestion, idx) => {
+            const suggestionText = `${suggestion.icon} ${suggestion.name}`.padEnd(suggestionWidth - borderWidth, " ");
+            const truncatedSuggestion = truncateText(suggestionText, suggestionWidth - 2);
+            return idx == activeSuggestionIdx ? chalk.bgHex(activeSuggestionBackgroundColor)(truncatedSuggestion) : truncatedSuggestion;
+        }), suggestionWidth, x);
+    }
+    async render(remainingLines) {
+        await this._loadSuggestions();
+        if (!this.#suggestBlob)
+            return { data: "", rows: 0 };
+        const { suggestions, argumentDescription } = this.#suggestBlob;
+        const page = Math.min(Math.floor(this.#activeSuggestionIdx / maxSuggestions) + 1, Math.floor(suggestions.length / maxSuggestions) + 1);
+        const pagedSuggestions = suggestions.filter((_, idx) => idx < page * maxSuggestions && idx >= (page - 1) * maxSuggestions);
+        const activePagedSuggestionIndex = this.#activeSuggestionIdx % maxSuggestions;
+        const activeDescription = pagedSuggestions.at(activePagedSuggestionIndex)?.description || argumentDescription || "";
+        const wrappedPadding = this.#term.getCursorState().cursorX % this.#term.cols;
+        const maxPadding = activeDescription.length !== 0 ? this.#term.cols - suggestionWidth - descriptionWidth : this.#term.cols - suggestionWidth;
+        const swapDescription = wrappedPadding > maxPadding && activeDescription.length !== 0;
+        const swappedPadding = swapDescription ? Math.max(wrappedPadding - descriptionWidth, 0) : wrappedPadding;
+        const clampedLeftPadding = Math.min(Math.min(wrappedPadding, swappedPadding), maxPadding);
+        if (suggestions.length <= this.#activeSuggestionIdx) {
+            this.#activeSuggestionIdx = Math.max(suggestions.length - 1, 0);
+        }
+        if (pagedSuggestions.length == 0) {
+            if (argumentDescription != null) {
+                return {
+                    data: ansi.cursorHide +
+                        ansi.cursorUp(2) +
+                        ansi.cursorForward(clampedLeftPadding) +
+                        this._renderArgumentDescription(argumentDescription, clampedLeftPadding),
+                    rows: 3,
+                };
+            }
+            return { data: "", rows: 0 };
+        }
+        const suggestionRowsUsed = pagedSuggestions.length + borderWidth;
+        let descriptionRowsUsed = this._descriptionRows(activeDescription) + borderWidth;
+        let rows = Math.max(descriptionRowsUsed, suggestionRowsUsed);
+        if (rows <= remainingLines) {
+            descriptionRowsUsed = suggestionRowsUsed;
+            rows = suggestionRowsUsed;
+        }
+        const descriptionUI = ansi.cursorUp(descriptionRowsUsed - 1) +
+            (swapDescription
+                ? this._renderDescription(activeDescription, clampedLeftPadding)
+                : this._renderDescription(activeDescription, clampedLeftPadding + suggestionWidth)) +
+            ansi.cursorDown(descriptionRowsUsed - 1);
+        const suggestionUI = ansi.cursorUp(suggestionRowsUsed - 1) +
+            (swapDescription
+                ? this._renderSuggestions(pagedSuggestions, activePagedSuggestionIndex, clampedLeftPadding + descriptionWidth)
+                : this._renderSuggestions(pagedSuggestions, activePagedSuggestionIndex, clampedLeftPadding)) +
+            ansi.cursorDown(suggestionRowsUsed - 1);
+        const ui = swapDescription ? descriptionUI + suggestionUI : suggestionUI + descriptionUI;
+        return {
+            data: ansi.cursorHide + ansi.cursorForward(clampedLeftPadding) + ui + ansi.cursorShow,
+            rows,
+        };
+    }
+    update(input) {
+        const keyStroke = parseKeystroke(input);
+        if (keyStroke == null)
+            return false;
+        if (keyStroke == "esc") {
+            this.#suggestBlob = undefined;
+        }
+        else if (keyStroke == "up") {
+            this.#activeSuggestionIdx = Math.max(0, this.#activeSuggestionIdx - 1);
+        }
+        else if (keyStroke == "down") {
+            this.#activeSuggestionIdx = Math.min(this.#activeSuggestionIdx + 1, (this.#suggestBlob?.suggestions.length ?? 1) - 1);
+        }
+        else if (keyStroke == "tab") {
+            const removals = "\u007F".repeat(this.#suggestBlob?.charactersToDrop ?? 0);
+            const suggestion = this.#suggestBlob?.suggestions.at(this.#activeSuggestionIdx);
+            const chars = suggestion?.insertValue ?? suggestion?.name + " ";
+            if (this.#suggestBlob == null || !chars.trim() || this.#suggestBlob?.suggestions.length == 0) {
+                return false;
+            }
+            this.#term.write(removals + chars);
+        }
+        return "handled";
+    }
+}

package/build/ui/ui-root.js

@@ -1,71 +1,127 @@
 // 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();
+import ansi from "ansi-escapes";
+import chalk from "chalk";
+import { inputModifier } from "./input.js";
+import log from "../utils/log.js";
+import isterm from "../isterm/index.js";
+import { eraseLinesBelow } from "../utils/ansi.js";
+import { SuggestionManager, MAX_LINES } from "./suggestionManager.js";
+export const renderConfirmation = (live) => {
+    const statusMessage = live ? chalk.green("live") : chalk.red("not found");
+    return `inshellisense session [${statusMessage}]\n`;
+};
+export const render = async (shell) => {
+    const term = await isterm.spawn({ shell, rows: process.stdout.rows, cols: process.stdout.columns });
+    const suggestionManager = new SuggestionManager(term, shell);
+    let hasActiveSuggestions = false;
+    let previousSuggestionsRows = 0;
+    process.stdin.setRawMode(true);
+    const writeOutput = (data) => {
+        log.debug({ msg: "writing data", data });
+        process.stdout.write(data);
+    };
+    writeOutput(ansi.clearTerminal);
+    term.onData((data) => {
+        if (hasActiveSuggestions) {
+            // Considers when data includes newlines which have shifted the cursor position downwards
+            const newlines = Math.max((data.match(/\r/g) || []).length, (data.match(/\n/g) || []).length);
+            const linesOfInterest = MAX_LINES + newlines;
+            if (term.getCursorState().remainingLines <= previousSuggestionsRows) {
+                // handles when suggestions get loaded before shell output so you need to always clear below output as a precaution
+                if (term.getCursorState().remainingLines != 0) {
+                    writeOutput(ansi.cursorHide + ansi.cursorSavePosition + eraseLinesBelow(linesOfInterest + 1) + ansi.cursorRestorePosition);
+                }
+                writeOutput(data +
+                    ansi.cursorHide +
+                    ansi.cursorSavePosition +
+                    ansi.cursorPrevLine.repeat(linesOfInterest) +
+                    term.getCells(linesOfInterest, "above") +
+                    ansi.cursorRestorePosition +
+                    ansi.cursorShow);
+            }
+            else {
+                writeOutput(ansi.cursorHide + ansi.cursorSavePosition + eraseLinesBelow(linesOfInterest + 1) + ansi.cursorRestorePosition + ansi.cursorShow + data);
+            }
         }
-        if (key.return) {
-            setIsExiting(true);
+        else {
+            writeOutput(data);
         }
+        setImmediate(async () => {
+            const suggestion = await suggestionManager.render(term.getCursorState().remainingLines);
+            const commandState = term.getCommandState();
+            if (suggestion.data != "" && commandState.cursorTerminated && !commandState.hasOutput) {
+                if (hasActiveSuggestions) {
+                    if (term.getCursorState().remainingLines < suggestion.rows) {
+                        writeOutput(ansi.cursorHide +
+                            ansi.cursorSavePosition +
+                            ansi.cursorPrevLine.repeat(MAX_LINES) +
+                            term.getCells(MAX_LINES, "above") +
+                            ansi.cursorRestorePosition +
+                            ansi.cursorSavePosition +
+                            ansi.cursorUp() +
+                            suggestion.data +
+                            ansi.cursorRestorePosition +
+                            ansi.cursorShow);
+                    }
+                    else {
+                        const offset = MAX_LINES - suggestion.rows;
+                        writeOutput(ansi.cursorHide +
+                            ansi.cursorSavePosition +
+                            eraseLinesBelow(MAX_LINES) +
+                            (offset > 0 ? ansi.cursorUp(offset) : "") +
+                            suggestion.data +
+                            ansi.cursorRestorePosition +
+                            ansi.cursorShow);
+                    }
+                }
+                else {
+                    if (term.getCursorState().remainingLines < suggestion.rows) {
+                        writeOutput(ansi.cursorHide + ansi.cursorSavePosition + ansi.cursorUp() + suggestion.data + ansi.cursorRestorePosition + ansi.cursorShow);
+                    }
+                    else {
+                        writeOutput(ansi.cursorHide +
+                            ansi.cursorSavePosition +
+                            ansi.cursorNextLine.repeat(suggestion.rows) +
+                            suggestion.data +
+                            ansi.cursorRestorePosition +
+                            ansi.cursorShow);
+                    }
+                }
+                hasActiveSuggestions = true;
+            }
+            else {
+                if (hasActiveSuggestions) {
+                    if (term.getCursorState().remainingLines <= previousSuggestionsRows) {
+                        writeOutput(ansi.cursorHide +
+                            ansi.cursorSavePosition +
+                            ansi.cursorPrevLine.repeat(MAX_LINES) +
+                            term.getCells(MAX_LINES, "above") +
+                            ansi.cursorRestorePosition +
+                            ansi.cursorShow);
+                    }
+                    else {
+                        writeOutput(ansi.cursorHide + ansi.cursorSavePosition + eraseLinesBelow(MAX_LINES) + ansi.cursorRestorePosition + ansi.cursorShow);
+                    }
+                }
+                hasActiveSuggestions = false;
+            }
+            previousSuggestionsRows = suggestion.rows;
+        });
     });
-    useEffect(() => {
-        if (isExiting) {
-            uiResult = command;
-            exit();
+    process.stdin.on("data", (d) => {
+        const suggestionResult = suggestionManager.update(d);
+        if (previousSuggestionsRows > 0 && suggestionResult == "handled") {
+            term.noop();
         }
-    }, [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,
+        else if (suggestionResult != "fully-handled") {
+            term.write(inputModifier(d));
+        }
+    });
+    term.onExit(({ exitCode }) => {
+        process.exit(exitCode);
     });
-    const lines = wrappedText.split("\n");
-    return (lines.length - 1) * windowWidth + lines[lines.length - 1].length + Prompt.length;
-}
+    process.stdout.on("resize", () => {
+        term.resize(process.stdout.columns, process.stdout.rows);
+    });
+};

package/build/ui/ui-uninstall.js

@@ -1,10 +1,8 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 import chalk from "chalk";
-import { unbindAll, deleteConfigFolder } from "../utils/bindings.js";
+import { deleteConfigFolder } from "../utils/config.js";
 export const render = async () => {
-    await unbindAll();
-    process.stdout.write(chalk.green("✓") + " successfully uninstalled all existing bindings \n");
     deleteConfigFolder();
     process.stdout.write(chalk.green("✓") + " successfully deleted the .inshellisense config folder \n");
     process.stdout.write(chalk.magenta("•") + " to complete the uninstall, run the the command: " + chalk.underline(chalk.cyan("npm uninstall -g @microsoft/inshellisense")) + "\n");

package/build/ui/utils.js

@@ -0,0 +1,41 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import ansi from "ansi-escapes";
+import wrapAnsi from "wrap-ansi";
+import chalk from "chalk";
+/**
+ * Renders a box around the given rows
+ * @param rows the text content to be included in the box, must be <= width - 2
+ * @param width the max width of a row
+ * @param x the column to start the box at
+ */
+export const renderBox = (rows, width, x, borderColor) => {
+    const result = [];
+    const setColor = (text) => (borderColor ? chalk.hex(borderColor).apply(text) : text);
+    result.push(ansi.cursorTo(x) + setColor("┌" + "─".repeat(width - 2) + "┐") + ansi.cursorTo(x));
+    rows.forEach((row) => {
+        result.push(ansi.cursorDown() + setColor("│") + row + setColor("│") + ansi.cursorTo(x));
+    });
+    result.push(ansi.cursorDown() + setColor("└" + "─".repeat(width - 2) + "┘") + ansi.cursorTo(x));
+    return result.join("") + ansi.cursorUp(rows.length + 1);
+};
+export const truncateMultilineText = (description, width, maxHeight) => {
+    const wrappedText = wrapAnsi(description, width, {
+        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.map((line) => line.padEnd(width));
+};
+/**
+ * Truncates the text to the given width
+ */
+export const truncateText = (text, width) => {
+    const textPoints = [...text];
+    const slicedText = textPoints.slice(0, width - 1);
+    return slicedText.length == textPoints.length ? text.padEnd(width) : (slicedText.join("") + "…").padEnd(width);
+};

package/build/utils/ansi.js

@@ -0,0 +1,56 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+const ESC = "\u001B";
+const CSI = "\u001B[";
+const OSC = "\u001B]";
+const BEL = "\u0007";
+const SS3 = "\u001BO";
+export const IsTermOscPs = 6973;
+const IS_OSC = OSC + IsTermOscPs + ";";
+export var IstermOscPt;
+(function (IstermOscPt) {
+    IstermOscPt["PromptStarted"] = "PS";
+    IstermOscPt["PromptEnded"] = "PE";
+    IstermOscPt["CurrentWorkingDirectory"] = "CWD";
+})(IstermOscPt || (IstermOscPt = {}));
+export const IstermPromptStart = IS_OSC + IstermOscPt.PromptStarted + BEL;
+export const IstermPromptEnd = IS_OSC + IstermOscPt.PromptEnded + BEL;
+export const cursorHide = CSI + "?25l";
+export const cursorShow = CSI + "?25h";
+export const cursorNextLine = CSI + "E";
+export const eraseLine = CSI + "2K";
+export const cursorBackward = (count = 1) => CSI + count + "D";
+export const cursorTo = ({ x, y }) => {
+    return CSI + (y ?? "") + ";" + (x ?? "") + "H";
+};
+export const deleteLinesBelow = (count = 1) => {
+    return [...Array(count).keys()].map(() => CSI + "B" + CSI + "M").join("");
+};
+export const deleteLine = (count = 1) => CSI + count + "M";
+export const scrollUp = (count = 1) => CSI + count + "S";
+export const scrollDown = (count = 1) => CSI + count + "T";
+export const eraseLinesBelow = (count = 1) => {
+    return [...Array(count).keys()].map(() => cursorNextLine + eraseLine).join("");
+};
+export const parseKeystroke = (b) => {
+    let s;
+    if (b[0] > 127 && b[1] === undefined) {
+        b[0] -= 128;
+        s = "\u001B" + String(b);
+    }
+    else {
+        s = String(b);
+    }
+    if (s == ESC) {
+        return "esc";
+    }
+    else if (s == CSI + "A" || s == SS3 + "A") {
+        return "up";
+    }
+    else if (s == CSI + "B" || s == SS3 + "B") {
+        return "down";
+    }
+    else if (s == "\t") {
+        return "tab";
+    }
+};

package/build/utils/config.js

@@ -0,0 +1,68 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import os from "node:os";
+import path from "node:path";
+import fs from "node:fs";
+import fsAsync from "node:fs/promises";
+import _Ajv from "ajv";
+const Ajv = _Ajv;
+const ajv = new Ajv();
+const configSchema = {
+    type: "object",
+    properties: {
+        promptRegex: {
+            type: "object",
+            properties: {
+                bash: {
+                    type: "object",
+                    nullable: true,
+                    properties: {
+                        regex: { type: "string" },
+                        postfix: { type: "string" },
+                    },
+                    required: ["regex", "postfix"],
+                },
+                pwsh: {
+                    type: "object",
+                    nullable: true,
+                    properties: {
+                        regex: { type: "string" },
+                        postfix: { type: "string" },
+                    },
+                    required: ["regex", "postfix"],
+                },
+                powershell: {
+                    type: "object",
+                    nullable: true,
+                    properties: {
+                        regex: { type: "string" },
+                        postfix: { type: "string" },
+                    },
+                    required: ["regex", "postfix"],
+                },
+            },
+            nullable: true,
+        },
+    },
+    additionalProperties: false,
+};
+const configFolder = ".inshellisense";
+const cachePath = path.join(os.homedir(), configFolder, "config.json");
+let globalConfig = {};
+export const getConfig = () => globalConfig;
+export const loadConfig = async (program) => {
+    if (fs.existsSync(cachePath)) {
+        const config = JSON.parse((await fsAsync.readFile(cachePath)).toString());
+        const isValid = ajv.validate(configSchema, config);
+        if (!isValid) {
+            program.error("inshellisense config is invalid: " + ajv.errorsText());
+        }
+        globalConfig = config;
+    }
+};
+export const deleteConfigFolder = async () => {
+    const cliConfigPath = path.join(os.homedir(), configFolder);
+    if (fs.existsSync(cliConfigPath)) {
+        fs.rmSync(cliConfigPath, { recursive: true });
+    }
+};

package/build/utils/log.js

@@ -0,0 +1,30 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import os from "node:os";
+import path from "node:path";
+import fs from "node:fs";
+import fsAsync from "node:fs/promises";
+const logFolder = path.join(os.homedir(), ".inshellisense");
+const logTarget = path.join(logFolder, "inshellisense.log");
+let logEnabled = false;
+const reset = async () => {
+    if (!fs.existsSync(logTarget)) {
+        await fsAsync.mkdir(logFolder, { recursive: true });
+    }
+    await fsAsync.writeFile(logTarget, "");
+};
+const debug = (content) => {
+    if (!logEnabled) {
+        return;
+    }
+    fs.appendFile(logTarget, JSON.stringify(content) + "\n", (err) => {
+        if (err != null) {
+            throw err;
+        }
+    });
+};
+export const enable = async () => {
+    await reset();
+    logEnabled = true;
+};
+export default { reset, debug, enable };

package/build/utils/shell.js

@@ -2,9 +2,92 @@
 // Licensed under the MIT License.
 import process from "node:process";
 import find from "find-process";
-import { supportedShells } from "./bindings.js";
+import path from "node:path";
+import which from "which";
+import fs from "node:fs";
+import url from "node:url";
+import os from "node:os";
+import fsAsync from "node:fs/promises";
+export var Shell;
+(function (Shell) {
+    Shell["Bash"] = "bash";
+    Shell["Powershell"] = "powershell";
+    Shell["Pwsh"] = "pwsh";
+    Shell["Zsh"] = "zsh";
+    Shell["Fish"] = "fish";
+    Shell["Cmd"] = "cmd";
+})(Shell || (Shell = {}));
+export const supportedShells = [
+    Shell.Bash,
+    process.platform == "win32" ? Shell.Powershell : null,
+    Shell.Pwsh,
+    Shell.Zsh,
+    Shell.Fish,
+    process.platform == "win32" ? Shell.Cmd : null,
+].filter((shell) => shell != null);
+export const userZdotdir = process.env?.ZDOTDIR ?? os.homedir() ?? `~`;
+export const zdotdir = path.join(os.tmpdir(), `is-zsh`);
+const configFolder = ".inshellisense";
+export const setupBashPreExec = async () => {
+    const shellFolderPath = path.join(path.dirname(url.fileURLToPath(import.meta.url)), "..", "..", "shell");
+    const globalConfigPath = path.join(os.homedir(), configFolder);
+    if (!fs.existsSync(globalConfigPath)) {
+        await fsAsync.mkdir(globalConfigPath, { recursive: true });
+    }
+    await fsAsync.cp(path.join(shellFolderPath, "bash-preexec.sh"), path.join(globalConfigPath, "bash-preexec.sh"));
+};
+export const setupZshDotfiles = async () => {
+    const shellFolderPath = path.join(path.dirname(url.fileURLToPath(import.meta.url)), "..", "..", "shell");
+    await fsAsync.cp(path.join(shellFolderPath, "shellIntegration-rc.zsh"), path.join(zdotdir, ".zshrc"));
+    await fsAsync.cp(path.join(shellFolderPath, "shellIntegration-profile.zsh"), path.join(zdotdir, ".zprofile"));
+    await fsAsync.cp(path.join(shellFolderPath, "shellIntegration-env.zsh"), path.join(zdotdir, ".zshenv"));
+    await fsAsync.cp(path.join(shellFolderPath, "shellIntegration-login.zsh"), path.join(zdotdir, ".zlogin"));
+};
 export const inferShell = async () => {
+    try {
+        const name = path.parse(process.env.SHELL ?? "").name;
+        const shellName = supportedShells.find((shell) => name.includes(shell));
+        if (shellName)
+            return shellName;
+    }
+    catch {
+        /* empty */
+    }
     const processResult = (await find("pid", process.ppid)).at(0);
     const name = processResult?.name;
     return name != null ? supportedShells.find((shell) => name.includes(shell)) : undefined;
 };
+export const gitBashPath = async () => {
+    const gitBashPaths = await getGitBashPaths();
+    for (const gitBashPath of gitBashPaths) {
+        if (fs.existsSync(gitBashPath)) {
+            return gitBashPath;
+        }
+    }
+    throw new Error("unable to find a git bash executable installed");
+};
+const getGitBashPaths = async () => {
+    const gitDirs = new Set();
+    const gitExePath = await which("git.exe", { nothrow: true });
+    if (gitExePath) {
+        const gitExeDir = path.dirname(gitExePath);
+        gitDirs.add(path.resolve(gitExeDir, "../.."));
+    }
+    const addValid = (set, value) => {
+        if (value)
+            set.add(value);
+    };
+    // Add common git install locations
+    addValid(gitDirs, process.env["ProgramW6432"]);
+    addValid(gitDirs, process.env["ProgramFiles"]);
+    addValid(gitDirs, process.env["ProgramFiles(X86)"]);
+    addValid(gitDirs, `${process.env["LocalAppData"]}\\Program`);
+    const gitBashPaths = [];
+    for (const gitDir of gitDirs) {
+        gitBashPaths.push(`${gitDir}\\Git\\bin\\bash.exe`, `${gitDir}\\Git\\usr\\bin\\bash.exe`, `${gitDir}\\usr\\bin\\bash.exe`);
+    }
+    // Add special installs that don't follow the standard directory structure
+    gitBashPaths.push(`${process.env["UserProfile"]}\\scoop\\apps\\git\\current\\bin\\bash.exe`);
+    gitBashPaths.push(`${process.env["UserProfile"]}\\scoop\\apps\\git-with-openssh\\current\\bin\\bash.exe`);
+    return gitBashPaths;
+};