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

package/build/runtime/utils.js

@@ -1,22 +1,52 @@
 // 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);
-        });
+import path from "node:path";
+import { spawn } from "node:child_process";
+import fsAsync from "node:fs/promises";
+import { Shell } from "../utils/shell.js";
+import log from "../utils/log.js";
+export const buildExecuteShellCommand = (timeout) => async ({ command, env, args, cwd }) => {
+    const child = spawn(command, args, { cwd, env });
+    setTimeout(() => child.kill("SIGKILL"), timeout);
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (data) => (stdout += data));
+    child.stderr.on("data", (data) => (stderr += data));
+    child.on("error", (err) => {
+        log.debug({ msg: "shell command failed", e: err.message });
     });
-};
-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,
+                status: code ?? 0,
+                stderr,
+                stdout,
             });
         });
     });
 };
+export const resolveCwd = async (cmdToken, cwd, shell) => {
+    if (cmdToken == null)
+        return { cwd, pathy: false, complete: false };
+    const { token } = cmdToken;
+    const sep = shell == Shell.Bash ? "/" : path.sep;
+    if (!token.includes(sep))
+        return { cwd, pathy: false, complete: false };
+    const resolvedCwd = path.isAbsolute(token) ? token : path.join(cwd, token);
+    try {
+        await fsAsync.access(resolvedCwd, fsAsync.constants.R_OK);
+        return { cwd: resolvedCwd, pathy: true, complete: token.endsWith(sep) };
+    }
+    catch {
+        // fallback to the parent folder if possible
+        const baselessCwd = resolvedCwd.substring(0, resolvedCwd.length - path.basename(resolvedCwd).length);
+        try {
+            await fsAsync.access(baselessCwd, fsAsync.constants.R_OK);
+            return { cwd: baselessCwd, pathy: true, complete: token.endsWith(sep) };
+        }
+        catch {
+            /*empty*/
+        }
+        return { cwd, pathy: false, complete: false };
+    }
+};

package/build/ui/suggestionManager.js

@@ -17,11 +17,13 @@ export class SuggestionManager {
     #command;
     #activeSuggestionIdx;
     #suggestBlob;
-    constructor(terminal) {
+    #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;
@@ -33,7 +35,7 @@ export class SuggestionManager {
             return;
         }
         this.#command = commandText;
-        const suggestionBlob = await getSuggestions(commandText);
+        const suggestionBlob = await getSuggestions(commandText, this.#term.cwd, this.#shell);
         this.#suggestBlob = suggestionBlob;
     }
     _renderArgumentDescription(description, x) {
@@ -46,6 +48,11 @@ export class SuggestionManager {
             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, " ");
@@ -53,10 +60,10 @@ export class SuggestionManager {
             return idx == activeSuggestionIdx ? chalk.bgHex(activeSuggestionBackgroundColor)(truncatedSuggestion) : truncatedSuggestion;
         }), suggestionWidth, x);
     }
-    async render() {
+    async render(remainingLines) {
         await this._loadSuggestions();
         if (!this.#suggestBlob)
-            return { data: "", columns: 0 };
+            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);
@@ -77,20 +84,32 @@ export class SuggestionManager {
                         ansi.cursorUp(2) +
                         ansi.cursorForward(clampedLeftPadding) +
                         this._renderArgumentDescription(argumentDescription, clampedLeftPadding),
-                    columns: 3,
+                    rows: 3,
                 };
             }
-            return { data: "", columns: 0 };
+            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 columnsUsed = pagedSuggestions.length + borderWidth;
-        const ui = swapDescription
-            ? this._renderDescription(activeDescription, clampedLeftPadding) +
-                this._renderSuggestions(pagedSuggestions, activePagedSuggestionIndex, clampedLeftPadding + descriptionWidth)
-            : this._renderSuggestions(pagedSuggestions, activePagedSuggestionIndex, clampedLeftPadding) +
-                this._renderDescription(activeDescription, clampedLeftPadding + suggestionWidth);
+        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.cursorUp(columnsUsed - 1) + ansi.cursorForward(clampedLeftPadding) + ui + ansi.cursorShow,
-            columns: columnsUsed,
+            data: ansi.cursorHide + ansi.cursorForward(clampedLeftPadding) + ui + ansi.cursorShow,
+            rows,
         };
     }
     update(input) {
@@ -108,7 +127,8 @@ export class SuggestionManager {
         }
         else if (keyStroke == "tab") {
             const removals = "\u007F".repeat(this.#suggestBlob?.charactersToDrop ?? 0);
-            const chars = this.#suggestBlob?.suggestions.at(this.#activeSuggestionIdx)?.name + " ";
+            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;
             }

package/build/ui/ui-root.js

@@ -1,16 +1,21 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
+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 ansi from "ansi-escapes";
 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);
+    const suggestionManager = new SuggestionManager(term, shell);
     let hasActiveSuggestions = false;
-    let previousSuggestionsColumns = 0;
+    let previousSuggestionsRows = 0;
     process.stdin.setRawMode(true);
     const writeOutput = (data) => {
         log.debug({ msg: "writing data", data });
@@ -18,30 +23,36 @@ export const render = async (shell) => {
     };
     writeOutput(ansi.clearTerminal);
     term.onData((data) => {
-        const commandState = term.getCommandState();
-        if ((commandState.hasOutput || hasActiveSuggestions) && !commandState.persistentOutput) {
-            if (term.getCursorState().remainingLines < previousSuggestionsColumns) {
-                writeOutput(ansi.cursorHide +
+        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(MAX_LINES) +
-                    term.getCells(MAX_LINES, "above") +
+                    ansi.cursorPrevLine.repeat(linesOfInterest) +
+                    term.getCells(linesOfInterest, "above") +
                     ansi.cursorRestorePosition +
-                    ansi.cursorShow +
-                    data);
+                    ansi.cursorShow);
             }
             else {
-                writeOutput(ansi.cursorHide + ansi.cursorSavePosition + eraseLinesBelow(MAX_LINES + 1) + ansi.cursorRestorePosition + ansi.cursorShow + data);
+                writeOutput(ansi.cursorHide + ansi.cursorSavePosition + eraseLinesBelow(linesOfInterest + 1) + ansi.cursorRestorePosition + ansi.cursorShow + data);
             }
         }
         else {
             writeOutput(data);
         }
         setImmediate(async () => {
-            const suggestion = await suggestionManager.render();
+            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.columns) {
+                    if (term.getCursorState().remainingLines < suggestion.rows) {
                         writeOutput(ansi.cursorHide +
                             ansi.cursorSavePosition +
                             ansi.cursorPrevLine.repeat(MAX_LINES) +
@@ -54,7 +65,7 @@ export const render = async (shell) => {
                             ansi.cursorShow);
                     }
                     else {
-                        const offset = MAX_LINES - suggestion.columns;
+                        const offset = MAX_LINES - suggestion.rows;
                         writeOutput(ansi.cursorHide +
                             ansi.cursorSavePosition +
                             eraseLinesBelow(MAX_LINES) +
@@ -65,13 +76,13 @@ export const render = async (shell) => {
                     }
                 }
                 else {
-                    if (term.getCursorState().remainingLines < suggestion.columns) {
+                    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.columns) +
+                            ansi.cursorNextLine.repeat(suggestion.rows) +
                             suggestion.data +
                             ansi.cursorRestorePosition +
                             ansi.cursorShow);
@@ -81,7 +92,7 @@ export const render = async (shell) => {
             }
             else {
                 if (hasActiveSuggestions) {
-                    if (term.getCursorState().remainingLines < previousSuggestionsColumns) {
+                    if (term.getCursorState().remainingLines <= previousSuggestionsRows) {
                         writeOutput(ansi.cursorHide +
                             ansi.cursorSavePosition +
                             ansi.cursorPrevLine.repeat(MAX_LINES) +
@@ -95,12 +106,12 @@ export const render = async (shell) => {
                 }
                 hasActiveSuggestions = false;
             }
-            previousSuggestionsColumns = suggestion.columns;
+            previousSuggestionsRows = suggestion.rows;
         });
     });
     process.stdin.on("data", (d) => {
         const suggestionResult = suggestionManager.update(d);
-        if (previousSuggestionsColumns > 0 && suggestionResult == "handled") {
+        if (previousSuggestionsRows > 0 && suggestionResult == "handled") {
             term.noop();
         }
         else if (suggestionResult != "fully-handled") {

package/build/utils/ansi.js

@@ -11,6 +11,7 @@ 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;

package/build/utils/log.js

@@ -4,9 +4,13 @@ import os from "node:os";
 import path from "node:path";
 import fs from "node:fs";
 import fsAsync from "node:fs/promises";
-const logTarget = path.join(os.homedir(), ".inshellisense", "inshellisense.log");
-const logEnabled = false;
+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) => {
@@ -19,4 +23,8 @@ const debug = (content) => {
         }
     });
 };
-export default { reset, debug };
+export const enable = async () => {
+    await reset();
+    logEnabled = true;
+};
+export default { reset, debug, enable };

package/build/utils/shell.js

@@ -17,9 +17,25 @@ export var Shell;
     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].filter((shell) => shell != null);
+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"));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@microsoft/inshellisense",
-  "version": "0.0.1-rc.5",
+  "version": "0.0.1-rc.6",
   "description": "IDE style command line auto complete",
   "type": "module",
   "bin": {
@@ -18,7 +18,8 @@
     "start": "node ./build/index.js",
     "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js",
     "lint": "eslint src/ --ext .ts,.tsx && prettier src/ --check",
-    "lint:fix": "eslint src/ --ext .ts,.tsx --fix && prettier src/ --write"
+    "lint:fix": "eslint src/ --ext .ts,.tsx --fix && prettier src/ --write",
+    "debug": "node --inspect --loader ts-node/esm src/index.ts -V"
   },
   "repository": {
     "type": "git",
@@ -60,6 +61,7 @@
     "jest": "^29.7.0",
     "prettier": "3.0.3",
     "ts-jest": "^29.1.1",
+    "ts-node": "^10.9.2",
     "typescript": "^5.2.2"
   }
 }