@microsoft/inshellisense 0.0.1-rc.1

package/CODE_OF_CONDUCT.md

@@ -0,0 +1,9 @@
+# Microsoft Open Source Code of Conduct
+
+This project has adopted the [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/).
+
+Resources:
+
+- [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/)
+- [Microsoft Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/)
+- Contact [opencode@microsoft.com](mailto:opencode@microsoft.com) with questions or concerns

package/LICENSE

@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation.
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE

package/README.md

@@ -0,0 +1,55 @@
+# inshellisense
+
+`inshellisense` provides IDE style autocomplete for shells. It's a terminal native runtime for [autocomplete](https://github.com/withfig/autocomplete) which has support for 600+ command line tools. `inshellisense` supports Windows, Linux, & MacOS.
+
+<p align="center"><img alt="demo of inshellisense working" src="/docs/demo.gif" height="450px"/></p>
+
+## Getting Started
+
+### Installation
+
+```shell
+npm install -g @microsoft/inshellisense
+```
+
+### Quickstart
+
+After completing the installation, you can already run `inshellisense --shell <shell>` to start the autocomplete session for your desired shell. Additionally, you can bind `inshellisense` to a keybinding of `CTRL+a` by running the below command. This brings the added advantages of automatically starting the autocomplete session with your current shell and injecting any accepted command into your shell's history.
+
+```shell
+inshellisense bind
+```
+
+Additionally, inshellisense is also aliased under `is` after install for convenience.
+
+## Integrations
+
+inshellisense supports the following shells:
+
+- [bash](https://www.gnu.org/software/bash/)
+- [zsh](https://www.zsh.org/)
+- [fish](https://github.com/fish-shell/fish-shell)
+- [pwsh](https://github.com/PowerShell/PowerShell)
+- [powershell](https://learn.microsoft.com/en-us/powershell/scripting/windows-powershell/starting-windows-powershell) (Windows Powershell)
+
+## Contributing
+
+This project welcomes contributions and suggestions. Most contributions require you to agree to a
+Contributor License Agreement (CLA) declaring that you have the right to, and actually do, grant us
+the rights to use your contribution. For details, visit https://cla.opensource.microsoft.com.
+
+When you submit a pull request, a CLA bot will automatically determine whether you need to provide
+a CLA and decorate the PR appropriately (e.g., status check, comment). Simply follow the instructions
+provided by the bot. You will only need to do this once across all repos using our CLA.
+
+This project has adopted the [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/).
+For more information see the [Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/) or
+contact [opencode@microsoft.com](mailto:opencode@microsoft.com) with any additional questions or comments.
+
+## Trademarks
+
+This project may contain trademarks or logos for projects, products, or services. Authorized use of Microsoft
+trademarks or logos is subject to and must follow
+[Microsoft's Trademark & Brand Guidelines](https://www.microsoft.com/en-us/legal/intellectualproperty/trademarks/usage/general).
+Use of Microsoft trademarks or logos in modified versions of this project must not cause confusion or imply Microsoft sponsorship.
+Any use of third-party trademarks or logos are subject to those third-party's policies.

package/SECURITY.md

@@ -0,0 +1,41 @@
+<!-- BEGIN MICROSOFT SECURITY.MD V0.0.9 BLOCK -->
+
+## Security
+
+Microsoft takes the security of our software products and services seriously, which includes all source code repositories managed through our GitHub organizations, which include [Microsoft](https://github.com/Microsoft), [Azure](https://github.com/Azure), [DotNet](https://github.com/dotnet), [AspNet](https://github.com/aspnet) and [Xamarin](https://github.com/xamarin).
+
+If you believe you have found a security vulnerability in any Microsoft-owned repository that meets [Microsoft's definition of a security vulnerability](https://aka.ms/security.md/definition), please report it to us as described below.
+
+## Reporting Security Issues
+
+**Please do not report security vulnerabilities through public GitHub issues.**
+
+Instead, please report them to the Microsoft Security Response Center (MSRC) at [https://msrc.microsoft.com/create-report](https://aka.ms/security.md/msrc/create-report).
+
+If you prefer to submit without logging in, send email to [secure@microsoft.com](mailto:secure@microsoft.com).  If possible, encrypt your message with our PGP key; please download it from the [Microsoft Security Response Center PGP Key page](https://aka.ms/security.md/msrc/pgp).
+
+You should receive a response within 24 hours. If for some reason you do not, please follow up via email to ensure we received your original message. Additional information can be found at [microsoft.com/msrc](https://www.microsoft.com/msrc). 
+
+Please include the requested information listed below (as much as you can provide) to help us better understand the nature and scope of the possible issue:
+
+  * Type of issue (e.g. buffer overflow, SQL injection, cross-site scripting, etc.)
+  * Full paths of source file(s) related to the manifestation of the issue
+  * The location of the affected source code (tag/branch/commit or direct URL)
+  * Any special configuration required to reproduce the issue
+  * Step-by-step instructions to reproduce the issue
+  * Proof-of-concept or exploit code (if possible)
+  * Impact of the issue, including how an attacker might exploit the issue
+
+This information will help us triage your report more quickly.
+
+If you are reporting for a bug bounty, more complete reports can contribute to a higher bounty award. Please visit our [Microsoft Bug Bounty Program](https://aka.ms/security.md/msrc/bounty) page for more details about our active programs.
+
+## Preferred Languages
+
+We prefer all communications to be in English.
+
+## Policy
+
+Microsoft follows the principle of [Coordinated Vulnerability Disclosure](https://aka.ms/security.md/cvd).
+
+<!-- END MICROSOFT SECURITY.MD BLOCK -->

package/SUPPORT.md

@@ -0,0 +1,13 @@
+# Support
+
+## How to file issues and get help
+
+This project uses GitHub Issues to track bugs and feature requests. Please search the existing
+issues before filing new issues to avoid duplicates. For new issues, file your bug or
+feature request as a new Issue.
+
+For help and questions about using this project, create a new Github Discussion.
+
+## Microsoft Support Policy
+
+Support for this project is limited to the resources listed above.

package/build/commands/bind.js

@@ -0,0 +1,12 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import { Command } from "commander";
+import { supportedShells } from "../utils/bindings.js";
+import { render } from "../ui/ui-bind.js";
+const action = async () => {
+    await render();
+};
+const cmd = new Command("bind");
+cmd.description(`adds keybindings to the selected shell: ${supportedShells.join(", ")}`);
+cmd.action(action);
+export default cmd;

package/build/commands/root.js

@@ -0,0 +1,40 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import { render } from "../ui/ui-root.js";
+import { executeShellCommandTTY } from "../runtime/utils.js";
+import { saveCommand, loadCommand } from "../utils/cache.js";
+import { supportedShells as shells } from "../utils/bindings.js";
+export const supportedShells = shells.join(", ");
+export const action = async (options) => {
+    if (options.history) {
+        process.stdout.write(await loadCommand());
+        process.exit(0);
+    }
+    const shell = options.shell ?? "";
+    if (!shells.map((s) => s.valueOf()).includes(shell)) {
+        console.error(`Unsupported shell: '${shell}', supported shells: ${supportedShells}`);
+        process.exit(1);
+    }
+    let executed = false;
+    const commands = [];
+    let result = { code: 0 };
+    let startingCommand = options.command;
+    while (options.duration === "session" || !executed) {
+        const commandToExecute = await render(startingCommand);
+        if (commandToExecute == null || commandToExecute.trim().toLowerCase() == "exit" || commandToExecute.trim().toLowerCase() == "logout") {
+            result = { code: 0 };
+            break;
+        }
+        commands.push(commandToExecute);
+        result = await executeShellCommandTTY(shell, commandToExecute);
+        executed = true;
+        startingCommand = undefined;
+    }
+    await saveCommand(commands);
+    if (result.code) {
+        process.exit(result.code);
+    }
+    else {
+        process.exit(0);
+    }
+};

package/build/index.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+/* eslint-disable header/header */
+import { Command } from "commander";
+import bind from "./commands/bind.js";
+import { action, supportedShells } from "./commands/root.js";
+import { getVersion } from "./utils/version.js";
+const program = new Command();
+program
+    .name("inshellisense")
+    .description("IDE style command line auto complete")
+    .version(await getVersion(), "-v, --version", "output the current version")
+    .option("-s, --shell <shell>", `shell to use for command execution, supported shells: ${supportedShells}`)
+    .option("-c, --command <commmand>", "command to use as initial input")
+    .option("--history", "get the last command execute")
+    .option("-d, --duration <duration>", "duration of the autocomplete session, supported durations: single, session", "session")
+    .action(action);
+program.addCommand(bind);
+program.parse();

package/build/runtime/generator.js

@@ -0,0 +1,42 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import { runTemplates } from "./template.js";
+import { buildExecuteShellCommand } from "./utils.js";
+const getGeneratorContext = () => {
+    return {
+        environmentVariables: Object.fromEntries(Object.entries(process.env).filter((entry) => entry[1] != null)),
+        currentWorkingDirectory: process.cwd(),
+        currentProcess: "",
+        sshPrefix: "",
+        isDangerous: false,
+        searchTerm: "", // TODO: define search term
+    };
+};
+// 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);
+    const suggestions = [];
+    try {
+        if (script) {
+            const scriptOutput = typeof script === "function" ? script(tokens) : script != null ? await executeShellCommand(script) : "";
+            if (postProcess) {
+                suggestions.push(...postProcess(scriptOutput, tokens));
+            }
+            else if (splitOn) {
+                suggestions.push(...scriptOutput.split(splitOn).map((s) => ({ name: s })));
+            }
+        }
+        if (custom) {
+            suggestions.push(...(await custom(tokens, executeShellCommand, getGeneratorContext())));
+        }
+        if (template != null) {
+            suggestions.push(...(await runTemplates(template)));
+        }
+        return suggestions;
+    }
+    catch (e) {
+        /* empty */
+    }
+    return suggestions;
+};

package/build/runtime/model.js

@@ -0,0 +1,3 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+export {};

package/build/runtime/parser.js

@@ -0,0 +1,63 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+const cmdDelim = /(\|\|)|(&&)|(;)/;
+const spaceRegex = /\s/;
+export const parseCommand = (command) => {
+    const lastCommand = command.split(cmdDelim).at(-1)?.trimStart();
+    return lastCommand ? lex(lastCommand) : [];
+};
+const lex = (command) => {
+    const tokens = [];
+    let [readingQuotedString, readingFlag, readingCmd] = [false, false, false];
+    let readingIdx = 0;
+    let readingQuoteChar = "";
+    [...command].forEach((char, idx) => {
+        const reading = readingQuotedString || readingFlag || readingCmd;
+        if (!reading && (char === `'` || char === `"`)) {
+            [readingQuotedString, readingIdx, readingQuoteChar] = [true, idx, char];
+            return;
+        }
+        else if (!reading && char === `-`) {
+            [readingFlag, readingIdx] = [true, idx];
+            return;
+        }
+        else if (!reading && !spaceRegex.test(char)) {
+            [readingCmd, readingIdx] = [true, idx];
+            return;
+        }
+        if (readingQuotedString && char === readingQuoteChar && command.at(idx - 1) !== "\\") {
+            readingQuotedString = false;
+            const complete = idx + 1 < command.length && spaceRegex.test(command[idx + 1]);
+            tokens.push({
+                token: command.slice(readingIdx, idx + 1),
+                complete,
+                isOption: false,
+            });
+        }
+        else if ((readingFlag && spaceRegex.test(char)) || char === "=") {
+            readingFlag = false;
+            tokens.push({
+                token: command.slice(readingIdx, idx),
+                complete: true,
+                isOption: true,
+            });
+        }
+        else if (readingCmd && spaceRegex.test(char)) {
+            readingCmd = false;
+            tokens.push({
+                token: command.slice(readingIdx, idx),
+                complete: true,
+                isOption: false,
+            });
+        }
+    });
+    const reading = readingQuotedString || readingFlag || readingCmd;
+    if (reading) {
+        tokens.push({
+            token: command.slice(readingIdx),
+            complete: false,
+            isOption: false,
+        });
+    }
+    return tokens;
+};

package/build/runtime/runtime.js

@@ -0,0 +1,224 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import speclist, { diffVersionedCompletions as versionedSpeclist,
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
+ } from "@withfig/autocomplete/build/index.js";
+import { parseCommand } from "./parser.js";
+import { getArgDrivenRecommendation, getSubcommandDrivenRecommendation } from "./suggestion.js";
+import { buildExecuteShellCommand } from "./utils.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];
+        }
+    });
+});
+const loadedSpecs = {};
+const loadSpec = async (cmd) => {
+    const rootToken = cmd.at(0);
+    if (!rootToken?.complete) {
+        return;
+    }
+    if (loadedSpecs[rootToken.token]) {
+        return loadedSpecs[rootToken.token];
+    }
+    if (specSet[rootToken.token]) {
+        const spec = (await import(specSet[rootToken.token])).default;
+        loadedSpecs[rootToken.token] = spec;
+        return spec;
+    }
+};
+// this load spec function should only be used for `loadSpec` on the fly as it is cacheless
+const lazyLoadSpec = async (key) => {
+    return (await import(`@withfig/autocomplete/build/${key}.js`)).default;
+};
+// eslint-disable-next-line @typescript-eslint/no-unused-vars -- will be implemented in below TODO
+const lazyLoadSpecLocation = async (location) => {
+    return; //TODO: implement spec location loading
+};
+export const getSuggestions = async (cmd) => {
+    const activeCmd = parseCommand(cmd);
+    const rootToken = activeCmd.at(0);
+    if (activeCmd.length === 0 || !rootToken?.complete) {
+        return;
+    }
+    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);
+    if (result == null)
+        return;
+    const lastCommand = activeCmd.at(-1);
+    const charactersToDrop = lastCommand?.complete ? 0 : lastCommand?.token.length ?? 0;
+    return { ...result, charactersToDrop };
+};
+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));
+};
+// TODO: handle subcommands that are versioned
+const getSubcommand = (spec) => {
+    if (spec == null)
+        return;
+    if (typeof spec === "function") {
+        const potentialSubcommand = spec();
+        if (Object.prototype.hasOwnProperty.call(potentialSubcommand, "name")) {
+            return potentialSubcommand;
+        }
+        return;
+    }
+    return spec;
+};
+const executeShellCommand = buildExecuteShellCommand(5000);
+const genSubcommand = async (command, parentCommand) => {
+    const subcommandIdx = parentCommand.subcommands?.findIndex((s) => s.name === command);
+    if (subcommandIdx == null)
+        return;
+    const subcommand = parentCommand.subcommands?.at(subcommandIdx);
+    if (subcommand == null)
+        return;
+    // 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) {
+        case "function": {
+            const partSpec = await subcommand.loadSpec(command, executeShellCommand);
+            if (partSpec instanceof Array) {
+                const locationSpecs = (await Promise.all(partSpec.map((s) => lazyLoadSpecLocation(s)))).filter((s) => s != null);
+                const subcommands = locationSpecs.map((s) => getSubcommand(s)).filter((s) => s != null);
+                parentCommand.subcommands[subcommandIdx] = {
+                    ...subcommand,
+                    ...(subcommands.find((s) => s?.name == command) ?? []),
+                    loadSpec: undefined,
+                };
+                return parentCommand.subcommands[subcommandIdx];
+            }
+            else if (Object.prototype.hasOwnProperty.call(partSpec, "type")) {
+                const locationSingleSpec = await lazyLoadSpecLocation(partSpec);
+                parentCommand.subcommands[subcommandIdx] = {
+                    ...subcommand,
+                    ...(getSubcommand(locationSingleSpec) ?? []),
+                    loadSpec: undefined,
+                };
+                return parentCommand.subcommands[subcommandIdx];
+            }
+            else {
+                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 };
+            return parentCommand.subcommands[subcommandIdx];
+        }
+        case "object": {
+            parentCommand.subcommands[subcommandIdx] = { ...subcommand, ...(subcommand.loadSpec ?? {}), loadSpec: undefined };
+            return parentCommand.subcommands[subcommandIdx];
+        }
+        case "undefined": {
+            return subcommand;
+        }
+    }
+};
+const getOption = (activeToken, options) => {
+    return options.find((o) => (typeof o.name === "string" ? o.name === activeToken.token : o.name.includes(activeToken.token)));
+};
+const getPersistentTokens = (tokens) => {
+    return tokens.filter((t) => t.isPersistent === true);
+};
+const getArgs = (args) => {
+    return args instanceof Array ? args : args != null ? [args] : [];
+};
+const runOption = async (tokens, option, subcommand, persistentOptions, acceptedTokens) => {
+    if (tokens.length === 0) {
+        throw new Error("invalid state reached, option expected but no tokens found");
+    }
+    const activeToken = tokens[0];
+    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 runSubcommand(tokens.slice(1), subcommand, persistentOptions, acceptedTokens.concat({ ...activeToken, isPersistent }));
+};
+const runArg = async (tokens, args, subcommand, persistentOptions, acceptedTokens, fromOption, fromVariadic) => {
+    if (args.length === 0) {
+        return runSubcommand(tokens, subcommand, persistentOptions, acceptedTokens, true, !fromOption);
+    }
+    else if (tokens.length === 0) {
+        return await getArgDrivenRecommendation(args, subcommand, persistentOptions, undefined, acceptedTokens, fromVariadic);
+    }
+    else if (!tokens.at(0)?.complete) {
+        return await getArgDrivenRecommendation(args, subcommand, persistentOptions, tokens[0].token, acceptedTokens, fromVariadic);
+    }
+    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;
+        }
+        const nextSubcommand = await genSubcommand(activeToken.token, subcommand);
+        if (nextSubcommand != null) {
+            return runSubcommand(tokens.slice(1), nextSubcommand, 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);
+    }
+    else if (activeArg.isCommand) {
+        if (tokens.length <= 0) {
+            return;
+        }
+        const spec = await loadSpec(tokens);
+        if (spec == null)
+            return;
+        const subcommand = getSubcommand(spec);
+        if (subcommand == null)
+            return;
+        return runSubcommand(tokens.slice(1), subcommand);
+    }
+    return runArg(tokens.slice(1), args.slice(1), subcommand, persistentOptions, acceptedTokens.concat(activeToken), fromOption, false);
+};
+const runSubcommand = async (tokens, subcommand, persistentOptions = [], acceptedTokens = [], argsDepleted = false, argsUsed = false) => {
+    if (tokens.length === 0) {
+        return getSubcommandDrivenRecommendation(subcommand, persistentOptions, undefined, argsDepleted, argsUsed, acceptedTokens);
+    }
+    else if (!tokens.at(0)?.complete) {
+        return getSubcommandDrivenRecommendation(subcommand, persistentOptions, tokens[0].token, argsDepleted, argsUsed, acceptedTokens);
+    }
+    const activeToken = tokens[0];
+    const activeArgsLength = subcommand.args instanceof Array ? subcommand.args.length : 1;
+    const allOptions = [...persistentOptions, ...(subcommand.options ?? [])];
+    if (activeToken.isOption) {
+        const option = getOption(activeToken, allOptions);
+        if (option != null) {
+            return runOption(tokens, option, subcommand, 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)));
+    }
+    if (activeArgsLength <= 0) {
+        return; // not subcommand or option & no args exist
+    }
+    return runArg(tokens, getArgs(subcommand.args), subcommand, allOptions, acceptedTokens, false, false);
+};