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

package/build/ui/ui-root.js

@@ -1,71 +1,137 @@
 // 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 readline from "node:readline";
+import ansi from "ansi-escapes";
+import chalk from "chalk";
+import log from "../utils/log.js";
+import { getBackspaceSequence } 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 (program, shell, underTest, login) => {
+    const term = await isterm.spawn(program, { shell, rows: process.stdout.rows, cols: process.stdout.columns, underTest, login });
+    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);
+            }
         }
-        if (key.return) {
-            setIsExiting(true);
+        else {
+            writeOutput(data);
         }
+        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;
+        });
     });
-    useEffect(() => {
-        if (isExiting) {
-            uiResult = command;
-            exit();
+    process.stdin.on("keypress", (...keyPress) => {
+        const press = keyPress[1];
+        const inputHandled = suggestionManager.update(press);
+        if (previousSuggestionsRows > 0 && inputHandled) {
+            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 (!inputHandled) {
+            if (press.name == "backspace") {
+                term.write(getBackspaceSequence(keyPress, shell));
+            }
+            else {
+                term.write(press.sequence);
+            }
+        }
+    });
+    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,11 +1,9 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 import chalk from "chalk";
-import { unbindAll, deleteConfigFolder } from "../utils/bindings.js";
+import { deleteCacheFolder } 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");
+    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,57 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import ansi from "ansi-escapes";
+import { resetColor } from "../utils/ansi.js";
+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) => resetColor + (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,37 @@
+// 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["Prompt"] = "PROMPT";
+})(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 resetColor = CSI + "0m";
+export const resetLine = CSI + "2K";
+export const cursorBackward = (count = 1) => CSI + count + "D";
+export const cursorForward = (count = 1) => CSI + count + "C";
+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,132 @@
+// 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 specPathsSchema = {
+    type: "array",
+    items: { type: "string" },
+    nullable: true,
+};
+const configSchema = {
+    type: "object",
+    nullable: true,
+    properties: {
+        bindings: {
+            type: "object",
+            nullable: true,
+            properties: {
+                nextSuggestion: bindingSchema,
+                previousSuggestion: bindingSchema,
+                dismissSuggestions: bindingSchema,
+                acceptSuggestion: bindingSchema,
+            },
+        },
+        // DEPRECATED: prompt patterns are no longer used
+        prompt: {
+            type: "object",
+            nullable: true,
+            properties: {
+                bash: promptPatternsSchema,
+                pwsh: promptPatternsSchema,
+                powershell: promptPatternsSchema,
+                xonsh: promptPatternsSchema,
+                nu: promptPatternsSchema,
+                fish: promptPatternsSchema,
+            },
+        },
+        specs: {
+            type: "object",
+            nullable: true,
+            properties: {
+                path: specPathsSchema,
+            },
+        },
+    },
+    additionalProperties: false,
+};
+const rcFile = ".inshellisenserc";
+const xdgFile = "rc.toml";
+const cachePath = path.join(os.homedir(), ".inshellisense");
+const rcPath = path.join(os.homedir(), rcFile);
+const xdgPath = path.join(os.homedir(), ".config", "inshellisense", xdgFile);
+const configPaths = [rcPath, xdgPath];
+let globalConfig = {
+    bindings: {
+        nextSuggestion: { key: "down" },
+        previousSuggestion: { key: "up" },
+        acceptSuggestion: { key: "tab" },
+        dismissSuggestions: { key: "escape" },
+    },
+};
+export const getConfig = () => globalConfig;
+export const loadConfig = async (program) => {
+    configPaths.forEach(async (configPath) => {
+        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(`${configPath} is invalid toml. Parsing error on line ${e.line}, column ${e.column}: ${e.message}`);
+            }
+            const isValid = ajv.validate(configSchema, config);
+            if (!isValid) {
+                program.error(`${configPath} 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 ?? globalConfig?.prompt?.bash,
+                    powershell: config.prompt?.powershell ?? globalConfig?.prompt?.powershell,
+                    xonsh: config.prompt?.xonsh ?? globalConfig?.prompt?.xonsh,
+                    pwsh: config.prompt?.pwsh ?? globalConfig?.prompt?.pwsh,
+                    nu: config.prompt?.nu ?? globalConfig?.prompt?.nu,
+                    fish: config.prompt?.fish ?? globalConfig?.prompt?.fish,
+                },
+                specs: {
+                    path: [...(config?.specs?.path ?? []), ...(config?.specs?.path ?? [])],
+                },
+            };
+        }
+    });
+    globalConfig.specs = { path: [`${os.homedir()}/.fig/autocomplete/build`, ...(globalConfig.specs?.path ?? [])] };
+};
+export const deleteCacheFolder = () => {
+    if (fs.existsSync(cachePath)) {
+        fs.rmSync(cachePath, { recursive: true });
+    }
+};

package/build/utils/log.js

@@ -0,0 +1,39 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+/* eslint-disable @typescript-eslint/no-explicit-any */
+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;
+        }
+    });
+};
+const getLogFunction = (level) => (...data) => debug({ msg: `console.${level}`, data: data.toString() });
+const logConsole = {
+    ...console,
+    log: getLogFunction("log"),
+    error: getLogFunction("error"),
+};
+// eslint-disable-next-line no-global-assign
+const overrideConsole = () => (console = logConsole);
+export const enable = async () => {
+    await reset();
+    logEnabled = true;
+};
+export default { reset, debug, enable, overrideConsole };