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

package/build/runtime/alias.js

@@ -0,0 +1,61 @@
+// 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 = await 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(), env: { ISTERM: "1" } });
+    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) + " ", Shell.Bash);
+    });
+};
+const loadZshAliases = async () => {
+    const { stdout, stderr, status } = await executeShellCommand({ command: Shell.Zsh, args: ["-i", "-c", "alias"], cwd: process.cwd(), env: { ISTERM: "1" } });
+    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) + " ", Shell.Zsh);
+    });
+};
+export const loadAliases = async (shell) => {
+    switch (shell) {
+        case Shell.Bash:
+            await loadBashAliases();
+            break;
+        case Shell.Zsh:
+            await loadZshAliases();
+            break;
+    }
+    return [];
+};
+export const getAliasNames = () => Object.keys(loadedAliases);
+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/generator.js

@@ -1,11 +1,12 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
+import log from "../utils/log.js";
 import { runTemplates } from "./template.js";
 import { buildExecuteShellCommand } from "./utils.js";
-const getGeneratorContext = () => {
+const getGeneratorContext = (cwd) => {
     return {
         environmentVariables: Object.fromEntries(Object.entries(process.env).filter((entry) => entry[1] != null)),
-        currentWorkingDirectory: process.cwd(),
+        currentWorkingDirectory: cwd,
         currentProcess: "",
         sshPrefix: "",
         isDangerous: false,
@@ -13,30 +14,42 @@ const getGeneratorContext = () => {
     };
 };
 // TODO: add support for caching, trigger, & getQueryTerm
-export const runGenerator = async (generator, tokens) => {
-    const { script, postProcess, scriptTimeout, splitOn, custom, template } = generator;
-    const executeShellCommand = buildExecuteShellCommand(scriptTimeout ?? 5000);
+export const runGenerator = async (generator, tokens, cwd) => {
+    // TODO: support trigger
+    const { script, postProcess, scriptTimeout, splitOn, custom, template, filterTemplateSuggestions } = generator;
+    const executeShellCommand = await buildExecuteShellCommand(scriptTimeout ?? 5000);
     const suggestions = [];
     try {
         if (script) {
-            const scriptOutput = typeof script === "function" ? script(tokens) : script != null ? await executeShellCommand(script) : "";
+            const shellInput = typeof script === "function" ? script(tokens) : script;
+            const scriptOutput = Array.isArray(shellInput)
+                ? await executeShellCommand({ command: shellInput.at(0) ?? "", args: shellInput.slice(1), cwd })
+                : await executeShellCommand({ ...shellInput, cwd });
+            const scriptStdout = scriptOutput.stdout.trim();
             if (postProcess) {
-                suggestions.push(...postProcess(scriptOutput, tokens));
+                suggestions.push(...postProcess(scriptStdout, tokens));
             }
             else if (splitOn) {
-                suggestions.push(...scriptOutput.split(splitOn).map((s) => ({ name: s })));
+                suggestions.push(...scriptStdout.split(splitOn).map((s) => ({ name: s })));
             }
         }
         if (custom) {
-            suggestions.push(...(await custom(tokens, executeShellCommand, getGeneratorContext())));
+            suggestions.push(...(await custom(tokens, executeShellCommand, getGeneratorContext(cwd))));
         }
         if (template != null) {
-            suggestions.push(...(await runTemplates(template)));
+            const templateSuggestions = await runTemplates(template, cwd);
+            if (filterTemplateSuggestions) {
+                suggestions.push(...filterTemplateSuggestions(templateSuggestions));
+            }
+            else {
+                suggestions.push(...templateSuggestions);
+            }
         }
         return suggestions;
     }
     catch (e) {
-        /* empty */
+        const err = typeof e === "string" ? e : e instanceof Error ? e.message : e;
+        log.debug({ msg: "generator failed", err, script, splitOn, template });
     }
     return suggestions;
 };

package/build/runtime/parser.js

@@ -1,19 +1,48 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
-const cmdDelim = /(\|\|)|(&&)|(;)/;
+import wcwidth from "wcwidth";
+import { getShellWhitespaceEscapeChar } from "./utils.js";
+const cmdDelim = /(\|\|)|(&&)|(;)|(\|)/;
 const spaceRegex = /\s/;
-export const parseCommand = (command) => {
+export const parseCommand = (command, shell) => {
     const lastCommand = command.split(cmdDelim).at(-1)?.trimStart();
-    return lastCommand ? lex(lastCommand) : [];
+    const tokens = lastCommand ? lex(lastCommand, shell) : [];
+    return sanitizeTokens(tokens, shell);
 };
-const lex = (command) => {
+const sanitizeTokens = (cmdTokens, shell) => unwrapQuotedTokens(unescapeSpaceTokens(cmdTokens, shell), shell);
+// remove escapes around spaces
+const unescapeSpaceTokens = (cmdTokens, shell) => {
+    const escapeChar = getShellWhitespaceEscapeChar(shell);
+    return cmdTokens.map((cmdToken) => {
+        const { token, isQuoted } = cmdToken;
+        if (!isQuoted && token.includes(`${escapeChar} `)) {
+            return { ...cmdToken, token: token.replaceAll(`${escapeChar} `, " ") };
+        }
+        return cmdToken;
+    });
+};
+// need to unwrap tokens that are quoted with content after the quotes like `"hello"world`
+const unwrapQuotedTokens = (cmdTokens, shell) => {
+    const escapeChar = getShellWhitespaceEscapeChar(shell);
+    return cmdTokens.map((cmdToken) => {
+        const { token, isQuoteContinued } = cmdToken;
+        if (isQuoteContinued) {
+            const quoteChar = token[0];
+            const unquotedToken = token.replaceAll(`${escapeChar}${quoteChar}`, "\u001B").replaceAll(quoteChar, "").replaceAll("\u001B", quoteChar);
+            return { ...cmdToken, token: unquotedToken };
+        }
+        return cmdToken;
+    });
+};
+const lex = (command, shell) => {
     const tokens = [];
-    let [readingQuotedString, readingFlag, readingCmd] = [false, false, false];
+    const escapeChar = getShellWhitespaceEscapeChar(shell);
+    let [readingQuotedString, readingQuoteContinuedString, readingFlag, readingCmd] = [false, false, false, false];
     let readingIdx = 0;
     let readingQuoteChar = "";
     [...command].forEach((char, idx) => {
-        const reading = readingQuotedString || readingFlag || readingCmd;
-        if (!reading && (char === `'` || char === `"`)) {
+        const reading = readingQuotedString || readingQuoteContinuedString || readingFlag || readingCmd;
+        if (!reading && (char === `'` || char === `"` || char == "`")) {
             [readingQuotedString, readingIdx, readingQuoteChar] = [true, idx, char];
             return;
         }
@@ -25,39 +54,80 @@ const lex = (command) => {
             [readingCmd, readingIdx] = [true, idx];
             return;
         }
-        if (readingQuotedString && char === readingQuoteChar && command.at(idx - 1) !== "\\") {
+        if (readingQuotedString && char === readingQuoteChar && command.at(idx - 1) !== escapeChar && !spaceRegex.test(command.at(idx + 1) ?? " ")) {
+            readingQuotedString = false;
+            readingQuoteContinuedString = true;
+        }
+        else if (readingQuotedString && char === readingQuoteChar && command.at(idx - 1) !== escapeChar) {
             readingQuotedString = false;
             const complete = idx + 1 < command.length && spaceRegex.test(command[idx + 1]);
             tokens.push({
-                token: command.slice(readingIdx, idx + 1),
+                token: command.slice(readingIdx + 1, idx),
+                tokenLength: wcwidth(command.slice(readingIdx + 1, idx)) + 2,
                 complete,
                 isOption: false,
+                isQuoted: true,
+            });
+        }
+        else if (readingQuoteContinuedString && spaceRegex.test(char) && command.at(idx - 1) !== escapeChar) {
+            readingQuoteContinuedString = false;
+            tokens.push({
+                token: command.slice(readingIdx, idx),
+                tokenLength: wcwidth(command.slice(readingIdx, idx)),
+                complete: true,
+                isOption: false,
+                isQuoted: true,
+                isQuoteContinued: true,
             });
         }
         else if ((readingFlag && spaceRegex.test(char)) || char === "=") {
             readingFlag = false;
             tokens.push({
                 token: command.slice(readingIdx, idx),
+                tokenLength: wcwidth(command.slice(readingIdx, idx)),
                 complete: true,
                 isOption: true,
             });
         }
-        else if (readingCmd && spaceRegex.test(char)) {
+        else if (readingCmd && spaceRegex.test(char) && command.at(idx - 1) !== escapeChar) {
             readingCmd = false;
             tokens.push({
                 token: command.slice(readingIdx, idx),
+                tokenLength: wcwidth(command.slice(readingIdx, idx)),
                 complete: true,
                 isOption: false,
             });
         }
     });
-    const reading = readingQuotedString || readingFlag || readingCmd;
+    const reading = readingQuotedString || readingQuoteContinuedString || readingFlag || readingCmd;
     if (reading) {
-        tokens.push({
-            token: command.slice(readingIdx),
-            complete: false,
-            isOption: false,
-        });
+        if (readingQuotedString) {
+            tokens.push({
+                token: command.slice(readingIdx + 1),
+                tokenLength: wcwidth(command.slice(readingIdx + 1)) + 1,
+                complete: false,
+                isOption: false,
+                isQuoted: true,
+            });
+        }
+        else if (readingQuoteContinuedString) {
+            tokens.push({
+                token: command.slice(readingIdx),
+                tokenLength: wcwidth(command.slice(readingIdx)),
+                complete: false,
+                isOption: false,
+                isQuoted: true,
+                isQuoteContinued: true,
+            });
+        }
+        else {
+            tokens.push({
+                token: command.slice(readingIdx),
+                tokenLength: wcwidth(command.slice(readingIdx)),
+                complete: false,
+                isOption: readingFlag,
+            });
+        }
     }
     return tokens;
 };

package/build/runtime/runtime.js

@@ -4,25 +4,35 @@ import speclist, { diffVersionedCompletions as versionedSpeclist,
 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
 // @ts-ignore
  } from "@withfig/autocomplete/build/index.js";
+import path from "node:path";
 import { parseCommand } from "./parser.js";
 import { getArgDrivenRecommendation, getSubcommandDrivenRecommendation } from "./suggestion.js";
-import { buildExecuteShellCommand } from "./utils.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 (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);
@@ -46,25 +56,53 @@ const lazyLoadSpec = async (key) => {
 const lazyLoadSpecLocation = async (location) => {
     return; //TODO: implement spec location loading
 };
-export const getSuggestions = async (cmd) => {
-    const activeCmd = parseCommand(cmd);
+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) => {
+    let activeCmd = parseCommand(cmd, shell);
     const rootToken = activeCmd.at(0);
     if (activeCmd.length === 0 || !rootToken?.complete) {
         return;
     }
+    activeCmd = aliasExpand(activeCmd);
     const spec = await loadSpec(activeCmd);
     if (spec == null)
         return;
     const subcommand = getSubcommand(spec);
     if (subcommand == null)
         return;
-    const result = await runSubcommand(activeCmd.slice(1), subcommand);
+    const lastCommand = activeCmd.at(-1);
+    const { cwd: resolvedCwd, pathy, complete: pathyComplete } = await resolveCwd(lastCommand, cwd, shell);
+    if (pathy && lastCommand) {
+        lastCommand.isPath = true;
+        lastCommand.isPathComplete = pathyComplete;
+    }
+    const result = await runSubcommand(activeCmd.slice(1), subcommand, resolvedCwd, shell);
     if (result == null)
         return;
-    const lastCommand = activeCmd.at(-1);
-    const charactersToDrop = lastCommand?.complete ? 0 : lastCommand?.token.length ?? 0;
+    const charactersToDrop = lastCommand?.complete ? 0 : lastCommand?.tokenLength;
     return { ...result, charactersToDrop };
 };
+export const getSpecNames = () => {
+    return Object.keys(specSet).filter((spec) => !spec.startsWith("@") && spec != "-");
+};
 const getPersistentOptions = (persistentOptions, options) => {
     const persistentOptionNames = new Set(persistentOptions.map((o) => (typeof o.name === "string" ? [o.name] : o.name)).flat());
     return persistentOptions.concat((options ?? []).filter((o) => (typeof o.name == "string" ? !persistentOptionNames.has(o.name) : o.name.some((n) => !persistentOptionNames.has(n))) && o.isPersistent === true));
@@ -82,14 +120,14 @@ const getSubcommand = (spec) => {
     }
     return spec;
 };
-const executeShellCommand = buildExecuteShellCommand(5000);
+const executeShellCommand = await buildExecuteShellCommand(5000);
 const genSubcommand = async (command, parentCommand) => {
-    const subcommandIdx = parentCommand.subcommands?.findIndex((s) => s.name === command);
-    if (subcommandIdx == null)
+    if (!parentCommand.subcommands || parentCommand.subcommands.length === 0)
         return;
-    const subcommand = parentCommand.subcommands?.at(subcommandIdx);
-    if (subcommand == null)
+    const subcommandIdx = parentCommand.subcommands.findIndex((s) => (Array.isArray(s.name) ? s.name.includes(command) : s.name === command));
+    if (subcommandIdx === -1)
         return;
+    const subcommand = parentCommand.subcommands[subcommandIdx];
     // this pulls in the spec from the load spec and overwrites the subcommand in the parent with the loaded spec.
     // then it returns the subcommand and clears the loadSpec field so that it doesn't get called again
     switch (typeof subcommand.loadSpec) {
@@ -115,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": {
@@ -142,7 +192,7 @@ const getPersistentTokens = (tokens) => {
 const getArgs = (args) => {
     return args instanceof Array ? args : args != null ? [args] : [];
 };
-const runOption = async (tokens, option, subcommand, persistentOptions, acceptedTokens) => {
+const runOption = async (tokens, option, subcommand, cwd, shell, persistentOptions, acceptedTokens) => {
     if (tokens.length === 0) {
         throw new Error("invalid state reached, option expected but no tokens found");
     }
@@ -150,37 +200,40 @@ const runOption = async (tokens, option, subcommand, persistentOptions, accepted
     const isPersistent = persistentOptions.some((o) => (typeof o.name === "string" ? o.name === activeToken.token : o.name.includes(activeToken.token)));
     if ((option.args instanceof Array && option.args.length > 0) || option.args != null) {
         const args = option.args instanceof Array ? option.args : [option.args];
-        return runArg(tokens.slice(1), args, subcommand, persistentOptions, acceptedTokens.concat(activeToken), true, false);
+        return runArg(tokens.slice(1), args, subcommand, cwd, shell, persistentOptions, acceptedTokens.concat(activeToken), true, false);
     }
-    return runSubcommand(tokens.slice(1), subcommand, persistentOptions, acceptedTokens.concat({ ...activeToken, isPersistent }));
+    return runSubcommand(tokens.slice(1), subcommand, cwd, shell, persistentOptions, acceptedTokens.concat({
+        ...activeToken,
+        isPersistent,
+    }));
 };
-const runArg = async (tokens, args, subcommand, persistentOptions, acceptedTokens, fromOption, fromVariadic) => {
+const runArg = async (tokens, args, subcommand, cwd, shell, persistentOptions, acceptedTokens, fromOption, fromVariadic) => {
     if (args.length === 0) {
-        return runSubcommand(tokens, subcommand, persistentOptions, acceptedTokens, true, !fromOption);
+        return runSubcommand(tokens, subcommand, cwd, shell, persistentOptions, acceptedTokens, true, !fromOption);
     }
     else if (tokens.length === 0) {
-        return await getArgDrivenRecommendation(args, subcommand, persistentOptions, undefined, acceptedTokens, fromVariadic);
+        return await getArgDrivenRecommendation(args, subcommand, persistentOptions, undefined, acceptedTokens, fromVariadic, cwd, shell);
     }
     else if (!tokens.at(0)?.complete) {
-        return await getArgDrivenRecommendation(args, subcommand, persistentOptions, tokens[0].token, acceptedTokens, fromVariadic);
+        return await getArgDrivenRecommendation(args, subcommand, persistentOptions, tokens[0], acceptedTokens, fromVariadic, cwd, shell);
     }
     const activeToken = tokens[0];
     if (args.every((a) => a.isOptional)) {
         if (activeToken.isOption) {
             const option = getOption(activeToken, persistentOptions.concat(subcommand.options ?? []));
             if (option != null) {
-                return runOption(tokens, option, subcommand, persistentOptions, acceptedTokens);
+                return runOption(tokens, option, subcommand, cwd, shell, persistentOptions, acceptedTokens);
             }
             return;
         }
         const nextSubcommand = await genSubcommand(activeToken.token, subcommand);
         if (nextSubcommand != null) {
-            return runSubcommand(tokens.slice(1), nextSubcommand, persistentOptions, getPersistentTokens(acceptedTokens.concat(activeToken)));
+            return runSubcommand(tokens.slice(1), nextSubcommand, cwd, shell, persistentOptions, getPersistentTokens(acceptedTokens.concat(activeToken)));
         }
     }
     const activeArg = args[0];
     if (activeArg.isVariadic) {
-        return runArg(tokens.slice(1), args, subcommand, persistentOptions, acceptedTokens.concat(activeToken), fromOption, true);
+        return runArg(tokens.slice(1), args, subcommand, cwd, shell, persistentOptions, acceptedTokens.concat(activeToken), fromOption, true);
     }
     else if (activeArg.isCommand) {
         if (tokens.length <= 0) {
@@ -192,16 +245,16 @@ const runArg = async (tokens, args, subcommand, persistentOptions, acceptedToken
         const subcommand = getSubcommand(spec);
         if (subcommand == null)
             return;
-        return runSubcommand(tokens.slice(1), subcommand);
+        return runSubcommand(tokens.slice(1), subcommand, cwd, shell);
     }
-    return runArg(tokens.slice(1), args.slice(1), subcommand, persistentOptions, acceptedTokens.concat(activeToken), fromOption, false);
+    return runArg(tokens.slice(1), args.slice(1), subcommand, cwd, shell, persistentOptions, acceptedTokens.concat(activeToken), fromOption, false);
 };
-const runSubcommand = async (tokens, subcommand, persistentOptions = [], acceptedTokens = [], argsDepleted = false, argsUsed = false) => {
+const runSubcommand = async (tokens, subcommand, cwd, shell, persistentOptions = [], acceptedTokens = [], argsDepleted = false, argsUsed = false) => {
     if (tokens.length === 0) {
-        return getSubcommandDrivenRecommendation(subcommand, persistentOptions, undefined, argsDepleted, argsUsed, acceptedTokens);
+        return getSubcommandDrivenRecommendation(subcommand, persistentOptions, undefined, argsDepleted, argsUsed, acceptedTokens, cwd, shell);
     }
     else if (!tokens.at(0)?.complete) {
-        return getSubcommandDrivenRecommendation(subcommand, persistentOptions, tokens[0].token, argsDepleted, argsUsed, acceptedTokens);
+        return getSubcommandDrivenRecommendation(subcommand, persistentOptions, tokens[0], argsDepleted, argsUsed, acceptedTokens, cwd, shell);
     }
     const activeToken = tokens[0];
     const activeArgsLength = subcommand.args instanceof Array ? subcommand.args.length : 1;
@@ -209,16 +262,21 @@ const runSubcommand = async (tokens, subcommand, persistentOptions = [], accepte
     if (activeToken.isOption) {
         const option = getOption(activeToken, allOptions);
         if (option != null) {
-            return runOption(tokens, option, subcommand, persistentOptions, acceptedTokens);
+            return runOption(tokens, option, subcommand, cwd, shell, persistentOptions, acceptedTokens);
         }
         return;
     }
     const nextSubcommand = await genSubcommand(activeToken.token, subcommand);
     if (nextSubcommand != null) {
-        return runSubcommand(tokens.slice(1), nextSubcommand, getPersistentOptions(persistentOptions, subcommand.options), getPersistentTokens(acceptedTokens.concat(activeToken)));
+        return runSubcommand(tokens.slice(1), nextSubcommand, cwd, shell, getPersistentOptions(persistentOptions, subcommand.options), getPersistentTokens(acceptedTokens.concat(activeToken)));
     }
     if (activeArgsLength <= 0) {
         return; // not subcommand or option & no args exist
     }
-    return runArg(tokens, getArgs(subcommand.args), subcommand, allOptions, acceptedTokens, false, false);
+    const args = getArgs(subcommand.args);
+    if (args.length != 0) {
+        return runArg(tokens, args, subcommand, cwd, shell, allOptions, acceptedTokens, false, false);
+    }
+    // if the subcommand has no args specified, fallback to the subcommand and ignore this item
+    return runSubcommand(tokens.slice(1), subcommand, cwd, shell, persistentOptions, acceptedTokens.concat(activeToken));
 };