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

package/build/ui/ui-root.js

@@ -1,71 +1,140 @@
 // 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);
+import readline from "node:readline";
+import ansi from "ansi-escapes";
+import chalk from "chalk";
+import log from "../utils/log.js";
+import { Shell } from "../utils/shell.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, underTest, parentTermExit) => {
+    const term = await isterm.spawn({ shell, rows: process.stdout.rows, cols: process.stdout.columns, underTest });
+    const suggestionManager = new SuggestionManager(term, shell);
+    let hasActiveSuggestions = false;
+    let previousSuggestionsRows = 0;
+    if (process.stdin.isTTY)
+        process.stdin.setRawMode(true);
+    readline.emitKeypressEvents(process.stdin);
+    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 <= MAX_LINES) {
+                // 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);
+            }
+        }
+        else {
+            writeOutput(data);
         }
-    }, []);
-    useInput((input, key) => {
-        if (key.ctrl && input.toLowerCase() == "d") {
-            uiResult = undefined;
-            exit();
+        process.nextTick(async () => {
+            // validate result to prevent stale suggestion being provided
+            const suggestion = suggestionManager.validate(await suggestionManager.render(term.getCursorState().remainingLines));
+            const commandState = term.getCommandState();
+            if (suggestion.data != "" && commandState.cursorTerminated && !commandState.hasOutput) {
+                if (hasActiveSuggestions) {
+                    if (term.getCursorState().remainingLines < MAX_LINES) {
+                        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 < MAX_LINES) {
+                        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 <= MAX_LINES) {
+                        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;
+        });
+    });
+    process.stdin.on("keypress", (...keyPress) => {
+        const press = keyPress[1];
+        const inputHandled = suggestionManager.update(press);
+        if (previousSuggestionsRows > 0 && inputHandled) {
+            term.noop();
         }
-        if (key.return) {
-            setIsExiting(true);
+        else if (!inputHandled) {
+            if (press.name == "backspace" && (shell === Shell.Pwsh || shell === Shell.Powershell || shell === Shell.Cmd)) {
+                term.write("\u007F");
+            }
+            else {
+                term.write(press.sequence);
+            }
         }
     });
-    useEffect(() => {
-        if (isExiting) {
-            uiResult = command;
-            exit();
+    term.onExit(({ exitCode }) => {
+        if (parentTermExit && process.ppid) {
+            process.kill(process.ppid);
         }
-    }, [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,
+        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

@@ -0,0 +1,9 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import chalk from "chalk";
+import { deleteCacheFolder } from "../utils/config.js";
+export const render = async () => {
+    deleteCacheFolder();
+    process.stdout.write(chalk.green("✓") + " successfully deleted the .inshellisense cache 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,56 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import ansi from "ansi-escapes";
+import wrapAnsi from "wrap-ansi";
+import chalk from "chalk";
+import wcwidth from "wcwidth";
+/**
+ * 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));
+};
+const wcPadEnd = (text, width, char = " ") => text + char.repeat(Math.max(width - wcwidth(text), 0));
+const wcPoints = (text, length) => {
+    const points = [...text];
+    const accPoints = [];
+    let accWidth = 0;
+    for (const point of points) {
+        const width = wcwidth(point);
+        if (width + accWidth > length) {
+            return wcwidth(accPoints.join("")) < length ? [accPoints.join(""), true] : [accPoints.slice(0, -1).join(""), true];
+        }
+        accPoints.push(point);
+        accWidth += width;
+    }
+    return [accPoints.join(""), false];
+};
+/**
+ * Truncates the text to the given width
+ */
+export const truncateText = (text, width) => {
+    const [points, truncated] = wcPoints(text, width);
+    return !truncated ? wcPadEnd(text, width) : wcPadEnd(points + "…", width);
+};

package/build/utils/ansi.js

@@ -0,0 +1,33 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+const ESC = "\u001B";
+const CSI = ESC + "[";
+const OSC = "\u001B]";
+const BEL = "\u0007";
+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("");
+};

package/build/utils/config.js

@@ -0,0 +1,107 @@
+// 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 toml from "toml";
+import _Ajv from "ajv";
+const Ajv = _Ajv;
+const ajv = new Ajv();
+const bindingSchema = {
+    type: "object",
+    nullable: true,
+    properties: {
+        shift: { type: "boolean", nullable: true },
+        control: { type: "boolean", nullable: true },
+        key: { type: "string" },
+    },
+    required: ["key"],
+};
+const promptPatternsSchema = {
+    type: "array",
+    nullable: true,
+    items: {
+        type: "object",
+        properties: {
+            regex: { type: "string" },
+            postfix: { type: "string" },
+        },
+        required: ["regex", "postfix"],
+    },
+};
+const configSchema = {
+    type: "object",
+    nullable: true,
+    properties: {
+        bindings: {
+            type: "object",
+            nullable: true,
+            properties: {
+                nextSuggestion: bindingSchema,
+                previousSuggestion: bindingSchema,
+                dismissSuggestions: bindingSchema,
+                acceptSuggestion: bindingSchema,
+            },
+        },
+        prompt: {
+            type: "object",
+            nullable: true,
+            properties: {
+                bash: promptPatternsSchema,
+                pwsh: promptPatternsSchema,
+                powershell: promptPatternsSchema,
+                xonsh: promptPatternsSchema,
+            },
+        },
+    },
+    additionalProperties: false,
+};
+const configFile = ".inshellisenserc";
+const cachePath = path.join(os.homedir(), ".inshellisense");
+const configPath = path.join(os.homedir(), configFile);
+let globalConfig = {
+    bindings: {
+        nextSuggestion: { key: "down" },
+        previousSuggestion: { key: "up" },
+        acceptSuggestion: { key: "tab" },
+        dismissSuggestions: { key: "escape" },
+    },
+};
+export const getConfig = () => globalConfig;
+export const loadConfig = async (program) => {
+    if (fs.existsSync(configPath)) {
+        let config;
+        try {
+            config = toml.parse((await fsAsync.readFile(configPath)).toString());
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        }
+        catch (e) {
+            program.error(`${configFile} is invalid toml. Parsing error on line ${e.line}, column ${e.column}: ${e.message}`);
+        }
+        const isValid = ajv.validate(configSchema, config);
+        if (!isValid) {
+            program.error(`${configFile} is invalid: ${ajv.errorsText()}`);
+        }
+        globalConfig = {
+            bindings: {
+                nextSuggestion: config?.bindings?.nextSuggestion ?? globalConfig.bindings.nextSuggestion,
+                previousSuggestion: config?.bindings?.previousSuggestion ?? globalConfig.bindings.previousSuggestion,
+                acceptSuggestion: config?.bindings?.acceptSuggestion ?? globalConfig.bindings.acceptSuggestion,
+                dismissSuggestions: config?.bindings?.dismissSuggestions ?? globalConfig.bindings.dismissSuggestions,
+            },
+            prompt: {
+                bash: config.prompt?.bash,
+                powershell: config.prompt?.powershell,
+                xonsh: config.prompt?.xonsh,
+                pwsh: config.prompt?.pwsh,
+            },
+        };
+    }
+};
+export const deleteCacheFolder = async () => {
+    const cliConfigPath = path.join(os.homedir(), cachePath);
+    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

@@ -0,0 +1,98 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import process from "node:process";
+import find from "find-process";
+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["Xonsh"] = "xonsh";
+})(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,
+    Shell.Xonsh,
+].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");
+};
+export const getPythonPath = async () => {
+    return await which("python", { nothrow: true });
+};
+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;
+};