@microsoft/inshellisense 0.0.1-rc.11 → 0.0.1-rc.12

package/build/commands/root.js

@@ -5,6 +5,8 @@ import { Shell, supportedShells as shells, setupZshDotfiles, setupBashPreExec }
 import { inferShell } from "../utils/shell.js";
 import { loadConfig } from "../utils/config.js";
 import log from "../utils/log.js";
+import { loadAliases } from "../runtime/alias.js";
+import { loadLocalSpecsSet } from "../runtime/runtime.js";
 export const supportedShells = shells.join(", ");
 export const action = (program) => async (options) => {
     const inISTerm = process.env.ISTERM === "1";
@@ -15,6 +17,7 @@ export const action = (program) => async (options) => {
     if (options.verbose)
         await log.enable();
     await loadConfig(program);
+    await loadLocalSpecsSet();
     const shell = options.shell ?? (await inferShell());
     if (shell == null) {
         program.error(`Unable to identify shell, use the -s/--shell option to provide your shell`, { exitCode: 1 });
@@ -28,5 +31,6 @@ export const action = (program) => async (options) => {
     else if (shell == Shell.Bash) {
         await setupBashPreExec();
     }
+    await loadAliases(shell);
     await render(shell, options.test ?? false, options.parentTermExit ?? false);
 };

package/build/isterm/commandManager.js

@@ -32,6 +32,8 @@ export class CommandManager {
         this.#activeCommand = { promptStartMarker: this.#terminal.registerMarker(0), hasOutput: false, cursorTerminated: false };
     }
     handlePromptEnd() {
+        if (this.#activeCommand.promptEndMarker != null)
+            return;
         this.#activeCommand.promptEndMarker = this.#terminal.registerMarker(0);
         if (this.#activeCommand.promptEndMarker?.line === this.#terminal.buffer.active.cursorY) {
             this.#activeCommand.promptEndX = this.#terminal.buffer.active.cursorX;
@@ -218,7 +220,9 @@ export class CommandManager {
             let lineY = this.#activeCommand.promptEndMarker.line;
             let line = this.#terminal.buffer.active.getLine(this.#activeCommand.promptEndMarker.line);
             let command = "";
+            let wrappedCommand = "";
             let suggestions = "";
+            let isWrapped = false;
             for (;;) {
                 for (let i = lineY == this.#activeCommand.promptEndMarker.line ? this.#activeCommand.promptText.length : 0; i < this.#terminal.cols; i++) {
                     if (command.endsWith("    "))
@@ -230,6 +234,7 @@ export class CommandManager {
                     const cleanedChars = chars == "" ? " " : chars;
                     if (!this._isSuggestion(cell) && suggestions.length == 0) {
                         command += cleanedChars;
+                        wrappedCommand += cleanedChars;
                     }
                     else {
                         suggestions += cleanedChars;
@@ -237,11 +242,16 @@ export class CommandManager {
                 }
                 lineY += 1;
                 line = this.#terminal.buffer.active.getLine(lineY);
-                if (!line?.isWrapped) {
+                const wrapped = line?.isWrapped || this.#terminal.buffer.active.cursorY + this.#terminal.buffer.active.baseY != lineY - 1;
+                isWrapped = isWrapped || wrapped;
+                if (!wrapped) {
                     break;
                 }
+                wrappedCommand = "";
             }
-            const cursorAtEndOfInput = (this.#activeCommand.promptText.length + command.trim().length) % this.#terminal.cols <= this.#terminal.buffer.active.cursorX;
+            const cursorAtEndOfInput = isWrapped
+                ? wrappedCommand.trim().length % this.#terminal.cols <= this.#terminal.buffer.active.cursorX
+                : (this.#activeCommand.promptText.length + command.trimEnd().length) % this.#terminal.cols <= this.#terminal.buffer.active.cursorX;
             let hasOutput = false;
             let cell = undefined;
             for (let i = 0; i < this.#terminal.cols; i++) {
@@ -253,7 +263,10 @@ export class CommandManager {
                     break;
                 }
             }
-            const commandPostfix = this.#activeCommand.promptText.length + command.trim().length < this.#terminal.buffer.active.cursorX ? " " : "";
+            const postfixActive = isWrapped
+                ? wrappedCommand.trim().length < this.#terminal.buffer.active.cursorX
+                : this.#activeCommand.promptText.length + command.trimEnd().length < this.#terminal.buffer.active.cursorX;
+            const commandPostfix = postfixActive ? " " : "";
             this.#activeCommand.persistentOutput = this.#activeCommand.hasOutput && hasOutput;
             this.#activeCommand.hasOutput = hasOutput;
             this.#activeCommand.suggestionsText = suggestions.trim();

package/build/runtime/alias.js

@@ -0,0 +1,60 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import log from "../utils/log.js";
+import { gitBashPath, Shell } from "../utils/shell.js";
+import { parseCommand } from "./parser.js";
+import { buildExecuteShellCommand } from "./utils.js";
+import os from "node:os";
+const loadedAliases = {};
+const platform = os.platform();
+const executeShellCommand = buildExecuteShellCommand(5000);
+const loadBashAliases = async () => {
+    const shellTarget = platform == "win32" ? await gitBashPath() : Shell.Bash;
+    const { stdout, stderr, status } = await executeShellCommand({ command: shellTarget, args: ["-i", "-c", "alias"], cwd: process.cwd() });
+    if (status !== 0) {
+        log.debug({ msg: "failed to load bash aliases", stderr, status });
+        return;
+    }
+    return stdout
+        .trim()
+        .split("\n")
+        .forEach((line) => {
+        const [alias, ...commandSegments] = line.replace("alias ", "").replaceAll("'\\''", "'").split("=");
+        loadedAliases[alias] = parseCommand(commandSegments.join("=").slice(1, -1) + " ");
+    });
+};
+const loadZshAliases = async () => {
+    const { stdout, stderr, status } = await executeShellCommand({ command: Shell.Zsh, args: ["-i", "-c", "alias"], cwd: process.cwd() });
+    if (status !== 0) {
+        log.debug({ msg: "failed to load zsh aliases", stderr, status });
+        return;
+    }
+    return stdout
+        .trim()
+        .split("\n")
+        .forEach((line) => {
+        const [alias, ...commandSegments] = line.replaceAll("'\\''", "'").split("=");
+        loadedAliases[alias] = parseCommand(commandSegments.join("=").slice(1, -1) + " ");
+    });
+};
+export const loadAliases = async (shell) => {
+    switch (shell) {
+        case Shell.Bash:
+            await loadBashAliases();
+            break;
+        case Shell.Zsh:
+            await loadZshAliases();
+            break;
+    }
+    return [];
+};
+export const aliasExpand = (command) => {
+    if (!command.at(0)?.complete)
+        return command;
+    const alias = loadedAliases[command.at(0)?.token ?? ""];
+    if (alias) {
+        log.debug({ msg: "expanding alias", alias, command: command.slice(1) });
+        return [...alias, ...command.slice(1)];
+    }
+    return command;
+};

package/build/runtime/runtime.js

@@ -8,25 +8,31 @@ import path from "node:path";
 import { parseCommand } from "./parser.js";
 import { getArgDrivenRecommendation, getSubcommandDrivenRecommendation } from "./suggestion.js";
 import { buildExecuteShellCommand, resolveCwd } from "./utils.js";
+import { aliasExpand } from "./alias.js";
+import { getConfig } from "../utils/config.js";
+import log from "../utils/log.js";
 // eslint-disable-next-line @typescript-eslint/no-explicit-any -- recursive type, setting as any
 const specSet = {};
-speclist.forEach((s) => {
-    let activeSet = specSet;
-    const specRoutes = s.split("/");
-    specRoutes.forEach((route, idx) => {
-        if (typeof activeSet !== "object") {
-            return;
-        }
-        if (idx === specRoutes.length - 1) {
-            const prefix = versionedSpeclist.includes(s) ? "/index.js" : `.js`;
-            activeSet[route] = `@withfig/autocomplete/build/${s}${prefix}`;
-        }
-        else {
-            activeSet[route] = activeSet[route] || {};
-            activeSet = activeSet[route];
-        }
+function loadSpecsSet(speclist, versionedSpeclist, specsPath) {
+    speclist.forEach((s) => {
+        let activeSet = specSet;
+        const specRoutes = s.split("/");
+        specRoutes.forEach((route, idx) => {
+            if (typeof activeSet !== "object") {
+                return;
+            }
+            if (idx === specRoutes.length - 1) {
+                const prefix = versionedSpeclist.includes(s) ? "/index.js" : `.js`;
+                activeSet[route] = `${specsPath}/${s}${prefix}`;
+            }
+            else {
+                activeSet[route] = activeSet[route] || {};
+                activeSet = activeSet[route];
+            }
+        });
     });
-});
+}
+loadSpecsSet(speclist, versionedSpeclist, `@withfig/autocomplete/build`);
 const loadedSpecs = {};
 const loadSpec = async (cmd) => {
     const rootToken = cmd.at(0);
@@ -50,12 +56,32 @@ const lazyLoadSpec = async (key) => {
 const lazyLoadSpecLocation = async (location) => {
     return; //TODO: implement spec location loading
 };
+export const loadLocalSpecsSet = async () => {
+    const specsPath = getConfig()?.specs?.path;
+    if (!specsPath) {
+        return;
+    }
+    try {
+        await Promise.allSettled(specsPath.map((specPath) => import(path.join(specPath, "index.js"))
+            .then((res) => {
+            const { default: speclist, diffVersionedCompletions: versionedSpeclist } = res;
+            loadSpecsSet(speclist, versionedSpeclist, specPath);
+        })
+            .catch((e) => {
+            log.debug({ msg: "load local spec failed", e: e.message, specPath });
+        })));
+    }
+    catch (e) {
+        log.debug({ msg: "load local specs failed", e: e.message, specsPath });
+    }
+};
 export const getSuggestions = async (cmd, cwd, shell) => {
-    const activeCmd = parseCommand(cmd);
+    let activeCmd = parseCommand(cmd);
     const rootToken = activeCmd.at(0);
     if (activeCmd.length === 0 || !rootToken?.complete) {
         return;
     }
+    activeCmd = aliasExpand(activeCmd);
     const spec = await loadSpec(activeCmd);
     if (spec == null)
         return;
@@ -127,17 +153,29 @@ const genSubcommand = async (command, parentCommand) => {
                 return parentCommand.subcommands[subcommandIdx];
             }
             else {
-                parentCommand.subcommands[subcommandIdx] = { ...subcommand, ...partSpec, loadSpec: undefined };
+                parentCommand.subcommands[subcommandIdx] = {
+                    ...subcommand,
+                    ...partSpec,
+                    loadSpec: undefined,
+                };
                 return parentCommand.subcommands[subcommandIdx];
             }
         }
         case "string": {
             const spec = await lazyLoadSpec(subcommand.loadSpec);
-            parentCommand.subcommands[subcommandIdx] = { ...subcommand, ...(getSubcommand(spec) ?? []), loadSpec: undefined };
+            parentCommand.subcommands[subcommandIdx] = {
+                ...subcommand,
+                ...(getSubcommand(spec) ?? []),
+                loadSpec: undefined,
+            };
             return parentCommand.subcommands[subcommandIdx];
         }
         case "object": {
-            parentCommand.subcommands[subcommandIdx] = { ...subcommand, ...(subcommand.loadSpec ?? {}), loadSpec: undefined };
+            parentCommand.subcommands[subcommandIdx] = {
+                ...subcommand,
+                ...(subcommand.loadSpec ?? {}),
+                loadSpec: undefined,
+            };
             return parentCommand.subcommands[subcommandIdx];
         }
         case "undefined": {
@@ -164,7 +202,10 @@ const runOption = async (tokens, option, subcommand, cwd, persistentOptions, acc
         const args = option.args instanceof Array ? option.args : [option.args];
         return runArg(tokens.slice(1), args, subcommand, cwd, persistentOptions, acceptedTokens.concat(activeToken), true, false);
     }
-    return runSubcommand(tokens.slice(1), subcommand, cwd, persistentOptions, acceptedTokens.concat({ ...activeToken, isPersistent }));
+    return runSubcommand(tokens.slice(1), subcommand, cwd, persistentOptions, acceptedTokens.concat({
+        ...activeToken,
+        isPersistent,
+    }));
 };
 const runArg = async (tokens, args, subcommand, cwd, persistentOptions, acceptedTokens, fromOption, fromVariadic) => {
     if (args.length === 0) {

package/build/utils/config.js

@@ -30,6 +30,11 @@ const promptPatternsSchema = {
         required: ["regex", "postfix"],
     },
 };
+const specPathsSchema = {
+    type: "array",
+    items: { type: "string" },
+    nullable: true,
+};
 const configSchema = {
     type: "object",
     nullable: true,
@@ -55,6 +60,13 @@ const configSchema = {
                 nu: promptPatternsSchema,
             },
         },
+        specs: {
+            type: "object",
+            nullable: true,
+            properties: {
+                path: specPathsSchema,
+            },
+        },
     },
     additionalProperties: false,
 };
@@ -98,6 +110,9 @@ export const loadConfig = async (program) => {
                 pwsh: config.prompt?.pwsh,
                 nu: config.prompt?.nu,
             },
+            specs: {
+                path: [`${os.homedir()}/.fig/autocomplete/build`, ...(config?.specs?.path ?? [])],
+            },
         };
     }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@microsoft/inshellisense",
-  "version": "0.0.1-rc.11",
+  "version": "0.0.1-rc.12",
   "description": "IDE style command line auto complete",
   "type": "module",
   "engines": {