@sasjs/cli 6.20.0 → 6.22.0

package/build/cli.d.ts

@@ -1,2 +1,20 @@
+/**
+ * The line printed when the arguments name no command the CLI registers.
+ *
+ * Kept apart from the printing so it can be asserted without standing up a
+ * logger, and so the two cases - a typo, and no argument at all - stay
+ * distinguishable in a script's output.
+ *
+ * @param name - the command as typed, empty when none was given
+ */
+export declare const unknownCommandMessage: (name: string) => string;
+/**
+ * The registered command nearest to what was typed, when one is close enough to
+ * be worth naming - so `sasjs lc` finds `logcheck` rather than only saying no.
+ *
+ * @param name - the command as typed
+ * @returns the suggestion, or `undefined` when nothing is close
+ */
+export declare const closestCommand: (name: string) => string | undefined;
 export declare function cli(args: string[]): Promise<void>;
 export declare function instantiateLogger(): Promise<void>;

package/build/cli.js

@@ -36,29 +36,103 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
     }
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.closestCommand = exports.unknownCommandMessage = void 0;
 exports.cli = cli;
 exports.instantiateLogger = instantiateLogger;
 var logger_1 = require("@sasjs/utils/logger");
 var utils_1 = require("./utils");
 var parse_1 = require("./types/command/parse");
+var help_1 = require("./commands/help/help");
+var command_1 = require("./types/command");
+/**
+ * The line printed when the arguments name no command the CLI registers.
+ *
+ * Kept apart from the printing so it can be asserted without standing up a
+ * logger, and so the two cases - a typo, and no argument at all - stay
+ * distinguishable in a script's output.
+ *
+ * @param name - the command as typed, empty when none was given
+ */
+var unknownCommandMessage = function (name) {
+    return name
+        ? "Invalid SASjs command: ".concat(name, ".")
+        : 'No command given - here is what this CLI can do.';
+};
+exports.unknownCommandMessage = unknownCommandMessage;
+/**
+ * The registered command nearest to what was typed, when one is close enough to
+ * be worth naming - so `sasjs lc` finds `logcheck` rather than only saying no.
+ *
+ * @param name - the command as typed
+ * @returns the suggestion, or `undefined` when nothing is close
+ */
+var closestCommand = function (name) {
+    var _a;
+    var typed = name.toLowerCase();
+    var names = (0, parse_1.commandNames)();
+    return (_a = names
+        .map(function (candidate) { return ({
+        candidate: candidate,
+        // A prefix is what the user was reaching for, so it outranks a short
+        // edit distance: `logc` means `logcheck`, not `doc`.
+        prefix: candidate.toLowerCase().startsWith(typed),
+        distance: editDistance(typed, candidate.toLowerCase())
+    }); })
+        .filter(function (_a) {
+        var prefix = _a.prefix, distance = _a.distance;
+        return prefix || distance <= 2;
+    })
+        .sort(function (a, b) { return Number(b.prefix) - Number(a.prefix) || a.distance - b.distance; })[0]) === null || _a === void 0 ? void 0 : _a.candidate;
+};
+exports.closestCommand = closestCommand;
+var editDistance = function (a, b) {
+    var rows = Array.from({ length: a.length + 1 }, function (_, i) { return [i]; });
+    for (var j = 1; j <= b.length; j++)
+        rows[0][j] = j;
+    for (var i = 1; i <= a.length; i++) {
+        for (var j = 1; j <= b.length; j++) {
+            rows[i][j] = Math.min(rows[i - 1][j] + 1, rows[i][j - 1] + 1, rows[i - 1][j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1));
+        }
+    }
+    return rows[a.length][b.length];
+};
 function cli(args) {
     return __awaiter(this, void 0, void 0, function () {
-        var command, returnCode;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
+        var command, name_1, suggestion, returnCode;
+        var _a, _b, _c, _d;
+        return __generator(this, function (_e) {
+            switch (_e.label) {
                 case 0: return [4 /*yield*/, (0, utils_1.setProjectDir)(args)];
                 case 1:
-                    _a.sent();
+                    _e.sent();
                     return [4 /*yield*/, instantiateLogger()];
                 case 2:
-                    _a.sent();
+                    _e.sent();
                     return [4 /*yield*/, (0, utils_1.loadProjectEnvVariables)()];
                 case 3:
-                    _a.sent();
+                    _e.sent();
                     command = (0, parse_1.parse)(args);
-                    return [4 /*yield*/, command.execute()];
+                    if (!!command) return [3 /*break*/, 6];
+                    name_1 = (0, parse_1.requestedCommandName)(args);
+                    (_a = process.logger) === null || _a === void 0 ? void 0 : _a.error((0, exports.unknownCommandMessage)(name_1));
+                    if (!!name_1) return [3 /*break*/, 5];
+                    return [4 /*yield*/, (0, help_1.printHelpText)()];
                 case 4:
-                    returnCode = _a.sent();
+                    _e.sent();
+                    process.exit(command_1.ReturnCode.InvalidCommand);
+                    return [2 /*return*/];
+                case 5:
+                    suggestion = (0, exports.closestCommand)(name_1);
+                    if (suggestion) {
+                        (_b = process.logger) === null || _b === void 0 ? void 0 : _b.info("Did you mean `sasjs ".concat(suggestion, "`?"));
+                    }
+                    (_c = process.logger) === null || _c === void 0 ? void 0 : _c.info("Commands: ".concat((0, parse_1.commandNames)().sort().join(', ')));
+                    (_d = process.logger) === null || _d === void 0 ? void 0 : _d.info('Run `sasjs help` for the full text, or `sasjs <command> --help` for one command.');
+                    process.exit(command_1.ReturnCode.InvalidCommand);
+                    return [2 /*return*/];
+                case 6: return [4 /*yield*/, command.execute()];
+                case 7:
+                    returnCode = _e.sent();
                     process.exit(returnCode);
                     return [2 /*return*/];
             }

package/build/cli.spec.js

@@ -89,6 +89,7 @@ var test_1 = require("./utils/test");
 var envVariablesModule = __importStar(require("./utils/loadEnvVariables"));
 var projectDirModule = __importStar(require("./utils/setProjectDir"));
 var parseModule = __importStar(require("./types/command/parse"));
+var helpModule = __importStar(require("./commands/help/help"));
 var utils_1 = require("@sasjs/utils");
 var commandBase_1 = require("./types/command/commandBase");
 var command_1 = require("./types/command");
@@ -163,6 +164,81 @@ describe('CLI command parsing', function () {
             }
         });
     }); });
+    describe('when the arguments name no command', function () {
+        var helpSpy = function () {
+            return jest
+                .spyOn(helpModule, 'printHelpText')
+                .mockImplementation(function () {
+                return Promise.resolve({ outputCommands: '', outputAliases: '' });
+            });
+        };
+        it('should print the whole help when no command is given', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var help;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        jest.spyOn(parseModule, 'parse').mockImplementation(function () { return undefined; });
+                        jest
+                            .spyOn(parseModule, 'requestedCommandName')
+                            .mockImplementation(function () { return ''; });
+                        jest.spyOn(parseModule, 'commandNames').mockImplementation(function () { return ['run']; });
+                        help = helpSpy();
+                        return [4 /*yield*/, (0, cli_1.cli)(['node', 'sasjs'])];
+                    case 1:
+                        _a.sent();
+                        expect(help).toHaveBeenCalledTimes(1);
+                        expect(process.exit).toHaveBeenCalledWith(command_1.ReturnCode.InvalidCommand);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('should list the commands when the name is unknown', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var help;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        jest.spyOn(parseModule, 'parse').mockImplementation(function () { return undefined; });
+                        jest
+                            .spyOn(parseModule, 'requestedCommandName')
+                            .mockImplementation(function () { return 'frobnicate'; });
+                        jest
+                            .spyOn(parseModule, 'commandNames')
+                            .mockImplementation(function () { return ['run', 'lint']; });
+                        help = helpSpy();
+                        return [4 /*yield*/, (0, cli_1.cli)(['node', 'sasjs', 'frobnicate'])
+                            // The full text is for `sasjs` on its own; a typo gets the list, which is
+                            // the part that answers it, rather than two hundred lines.
+                        ];
+                    case 1:
+                        _a.sent();
+                        // The full text is for `sasjs` on its own; a typo gets the list, which is
+                        // the part that answers it, rather than two hundred lines.
+                        expect(help).not.toHaveBeenCalled();
+                        expect(parseModule.commandNames).toHaveBeenCalled();
+                        expect(process.exit).toHaveBeenCalledWith(command_1.ReturnCode.InvalidCommand);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('should not execute anything', function () { return __awaiter(void 0, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        jest.spyOn(parseModule, 'parse').mockImplementation(function () { return undefined; });
+                        jest
+                            .spyOn(parseModule, 'requestedCommandName')
+                            .mockImplementation(function () { return 'x'; });
+                        jest.spyOn(parseModule, 'commandNames').mockImplementation(function () { return []; });
+                        helpSpy();
+                        return [4 /*yield*/, (0, cli_1.cli)(['node', 'sasjs', 'x'])];
+                    case 1:
+                        _a.sent();
+                        expect(mockCommand.execute).not.toHaveBeenCalled();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
     it('should return with the correct exit code on errors', function () { return __awaiter(void 0, void 0, void 0, function () {
         return __generator(this, function (_a) {
             switch (_a.label) {
@@ -179,6 +255,25 @@ describe('CLI command parsing', function () {
         });
     }); });
 });
+describe('closestCommand', function () {
+    it('suggests a command one letter away', function () {
+        expect((0, cli_1.closestCommand)('logchek')).toEqual('logcheck');
+    });
+    it('suggests the command a prefix belongs to', function () {
+        expect((0, cli_1.closestCommand)('logc')).toEqual('logcheck');
+    });
+    it('suggests nothing when the name is unrelated', function () {
+        expect((0, cli_1.closestCommand)('frobnicate')).toBeUndefined();
+    });
+});
+describe('unknownCommandMessage', function () {
+    it('names the command that was typed', function () {
+        expect((0, cli_1.unknownCommandMessage)('frobnicate')).toEqual('Invalid SASjs command: frobnicate.');
+    });
+    it('says no command was given when there is none', function () {
+        expect((0, cli_1.unknownCommandMessage)('')).toEqual('No command given - here is what this CLI can do.');
+    });
+});
 var setupMocks = function () {
     jest.resetAllMocks();
     (0, test_1.mockProcessExit)();
@@ -191,5 +286,13 @@ var setupMocks = function () {
         .spyOn(projectDirModule, 'setProjectDir')
         .mockImplementation(function () { return Promise.resolve(); });
     jest.spyOn(parseModule, 'parse').mockImplementation(function () { return mockCommand; });
+    jest
+        .spyOn(parseModule, 'requestedCommandName')
+        .mockImplementation(function () { return 'mock'; });
+    jest
+        .spyOn(helpModule, 'printHelpText')
+        .mockImplementation(function () {
+        return Promise.resolve({ outputCommands: '', outputAliases: '' });
+    });
     jest.spyOn(mockCommand, 'execute');
 };

package/build/commands/help/help.js

@@ -209,6 +209,8 @@ function printHelpText() {
                     description: [
                         "lets the user add a build target to either the local project configuration, or to the global .sasjsrc file.",
                         "",
+                        "[2spaces]NOTE: Providing insecure flag (--insecure or -i) is optional. It allows the command to bypass the HTTPS requirement, and is not recommended.",
+                        "",
                         "NOTE: This command requires the user to input all the required parameters. More information available in the online documentation: ".concat(chalk_1.default.cyanBright('https://sasjs.io/sasjs-cli-add'))
                     ]
                 },
@@ -220,6 +222,9 @@ function printHelpText() {
                         "With the 'login' sub command (SASVIYA targets only), authentication is performed with a SAS username and password - no OAuth client/secret required - and the resulting tokens are saved.",
                         "Without a sub command, behaves like 'sasjs add cred' (client/secret based authentication).",
                         "",
+                        "[2spaces]NOTE: Providing insecure flag (--insecure or -i) is optional. It allows the command to bypass the HTTPS requirement, and is not recommended.",
+                        "[2spaces]NOTE: Providing password-stdin flag (--passwordStdin) is optional. The password is read from stdin instead of being prompted for, which is how a pipeline passes it without a terminal.",
+                        "",
                         "NOTE: This command requires the user to input all the required parameters. More information available in the online documentation: ".concat(chalk_1.default.cyanBright('https://cli.sasjs.io/auth/'))
                     ]
                 },
@@ -231,7 +236,8 @@ function printHelpText() {
                         "The target can exist either in the local project configuration or in the global .sasjsrc file.",
                         "Providing log flag (--log or -l) is optional. If not present, the log is stored locally with a timestamp. If present, CLI will fetch and save the log to the specified location. If a relative location, it will be relative to the directory in which the command is invoked.",
                         "Providing source flag (--source or -s) is optional. It should point to a JSON file with the following structure:  {\"macroVars\": {\"var1\": \"val1\", \"var2\": \"val2\"}}. These will be parsed into SAS \"%let\" statements and pre-append to the SAS code being run.",
-                        "Providing compile flag (--compile or -c) is optional. It is used to compile the program prior to execution. Useful for including dependent macros and includes. More info here: https://cli.sasjs.io/compile"
+                        "Providing compile flag (--compile or -c) is optional. It is used to compile the program prior to execution. Useful for including dependent macros and includes. More info here: https://cli.sasjs.io/compile",
+                        "Providing logcheck flag (--logcheck or --no-logcheck) is optional. It checks the log this run returned and fails when the logCheck setting in sasjsconfig.json says so. --no-logcheck switches both the report and the verdict off for this run."
                     ]
                 },
                 {
@@ -243,7 +249,9 @@ function printHelpText() {
                         "The target can exist either in the local project configuration or in the global .sasjsrc file.",
                         "<sasProgramPath> - if this has a leading slash (eg /Public/app/folder/servicename) then it must be the full path. If it is a relative path (eg path/servicename) then it will be pre-pended with the appLoc - which must then be defined in the sasjs config.",
                         "<path/to/log> - Location in which to store the log file. If not provided AND current directory is a sasjs project, it will be saved in sasjsresults else in the current directory",
-                        "<path/to/output> - Location to store the output file. If not provided AND current directory is a sasjs project, an output file  will be saved in the sasjsresults folder else in current directory."
+                        "<path/to/output> - Location to store the output file. If not provided AND current directory is a sasjs project, an output file  will be saved in the sasjsresults folder else in current directory.",
+                        "<path/to/datafile> - (--data or -d) the json file holding the input data passed to the request. --config (-c) takes the json config for the execution itself.",
+                        "Providing logcheck flag (--logcheck or --no-logcheck) is optional. It checks the log this request returned and fails when the logCheck setting in sasjsconfig.json says so."
                     ]
                 },
                 {
@@ -274,7 +282,8 @@ function printHelpText() {
                         "* ".concat(chalk_1.default.cyanBright('compile'), " - Compiles a SAS program with the contents of a local directory."),
                         "[2spaces]command example: sasjs fs compile /Public/folder --output ./outputProgram",
                         "",
-                        "[2spaces]NOTE: If output flag (-o or --output) is not provided, output will be stored in './fs-compile/{timestamp}' directory relative to working directory."
+                        "[2spaces]NOTE: If output flag (-o or --output) is not provided, output will be stored in './fs-compile/{timestamp}' directory relative to working directory.",
+                        "[2spaces]NOTE: Providing logcheck flag (--logcheck or --no-logcheck) is optional. It checks the log the compile returned, and fails when the logCheck setting in sasjsconfig.json says so."
                     ]
                 },
                 {
@@ -290,7 +299,12 @@ function printHelpText() {
                         "[2spaces]NOTE: Providing output flag (--output or -o) is optional. If present, CLI will immediately print out the response JSON. If value is provided, it will be treated as file path to save the response JSON.",
                         "[2spaces]NOTE: Providing log flag (--log or -l) is optional. If present, CLI will fetch and save job log to local file.",
                         "[2spaces]NOTE: Providing ignore warnings (--ignoreWarnings or -i) flag is optional. If present, CLI will return status '0', when the job state is warning.",
-                        "[2spaces]NOTE: Providing verbose (--verbose or -v) flag is optional. If present, CLI will log summary of every HTTP response. If set to 'bleached', CLI will log summary of every HTTP response without extra colors."
+                        "[2spaces]NOTE: Providing verbose (--verbose or -v) flag is optional. If present, CLI will log summary of every HTTP response. If set to 'bleached', CLI will log summary of every HTTP response without extra colors.",
+                        "[2spaces]NOTE: Providing source flag (--source or -s) is optional. It points to a JSON file of job variables, of the form {\"macroVars\": {\"var1\": \"val1\"}}.",
+                        "[2spaces]NOTE: Providing returnStatusOnly (--returnStatusOnly or -r) is deprecated and has no effect: passing it prints a deprecation warning. The job status is returned with --verbose.",
+                        "[2spaces]NOTE: Providing statusFile flag (--statusFile) is optional. The job status is fetched and saved to the given path; with no path it is printed to the console.",
+                        "[2spaces]NOTE: Providing streamLog flag (--streamLog) is optional. As the job runs, its log is streamed into the local file given here, rather than fetched once at the end.",
+                        "[2spaces]NOTE: Providing logcheck flag (--logcheck or --no-logcheck) is optional. It checks the log the job returned, and fails when the logCheck setting in sasjsconfig.json says so."
                     ]
                 },
                 {
@@ -299,7 +313,10 @@ function printHelpText() {
                     description: [
                         "Performs operations on flows of jobs.",
                         "[2spaces]* ".concat(chalk_1.default.cyanBright('execute'), " - triggers flow for execution."),
-                        "[2spaces]command example: sasjs flow execute --source /local/flow.json --logFolder /local/log/folder --csvFile /local/some.csv"
+                        "[2spaces]command example: sasjs flow execute --source /local/flow.json --logFolder /local/log/folder --csvFile /local/some.csv",
+                        "",
+                        "[2spaces]NOTE: Providing streamLog flag (--streamLog) is optional. As each job in the flow runs, its log is streamed into the log folder, rather than fetched once the job finishes.",
+                        "[2spaces]NOTE: Providing logcheck flag (--logcheck or --no-logcheck) is optional. It checks the log of every job in the flow, and fails when the logCheck setting in sasjsconfig.json says so. A log streamed with --streamLog goes straight to its file and is not checked."
                     ]
                 },
                 {
@@ -323,7 +340,8 @@ function printHelpText() {
                     name: 'lint',
                     title: 'lint',
                     description: [
-                        "Provides the capability to identify, for SAS file, whether there are any ERRORs or WARNINGs present and if so, which line number they are on."
+                        "Provides the capability to identify, for SAS file, whether there are any ERRORs or WARNINGs present and if so, which line number they are on.",
+                        "[2spaces]command example: sasjs lint --fail-on warning"
                     ]
                 },
                 {
@@ -332,7 +350,11 @@ function printHelpText() {
                     description: [
                         "Checks SAS logs for the messages SAS printed - ERRORs, WARNINGs and the notes that flag a problem - and fails when the failure policy is broken.",
                         "[2spaces]With no path, the project's results folder is checked. No target, no login and no project are needed, so a log produced elsewhere checks the same way.",
-                        "[2spaces]command example: sasjs logcheck --fail-on warning --format json"
+                        "[2spaces]command example: sasjs logcheck --fail-on warning --format json",
+                        "",
+                        "[2spaces]Flags: --fail-on error|warning|note|never (defaults to logCheck.failOn in sasjsconfig.json, else error), --max-warnings <n>, --ignore-code <49-169>, --ignore-path <path segment|glob>, --format human|json|annotations, --json, --verbose.",
+                        "[2spaces]The same settings live in the logCheck section of sasjsconfig.json: --ignore-code and --ignore-path add to what the file lists, while --fail-on and --max-warnings replace the file's value when they are given.",
+                        "[2spaces]The exit code is 5 when the policy is broken, which is distinct from lint's 3, so a pipeline can tell a run SAS complained about from code-quality failures."
                     ]
                 },
                 {

package/build/commands/lint/lintCommand.js

@@ -50,6 +50,31 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
 };
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LintCommand = void 0;
 var initLint_1 = require("./initLint");
@@ -57,15 +82,35 @@ var processLint_1 = require("./processLint");
 var command_1 = require("../../types/command");
 var types_1 = require("../../types");
 var utils_1 = require("../../utils");
+var subCommands = ['init', 'fix', 'find'];
+var failOnValues = ['error', 'warning'];
 var syntax = 'lint <subCommand> [filterStrings..]';
-var usage = 'sasjs lint [ find | fix | init ]';
+var usage = 'sasjs lint [ find | fix | init ] [--fail-on error|warning]';
 var description = "Provides the capability to identify, for SAS file, whether there are any ERRORs or WARNINGs present and if so, which line number they are on.";
+/**
+ * Inserts the default `find` subcommand unless the first argument is already a
+ * subcommand, so `sasjs lint --fail-on warning` and `sasjs lint src/app.sas`
+ * both report rather than fail to parse. The check is made on the arguments
+ * rather than on their number, because an option and its value count as
+ * arguments and used to push the subcommand out of position.
+ */
+var withDefaultSubCommand = function (args) {
+    var firstPositional = args.slice(3).find(function (arg) { return !arg.startsWith('-'); });
+    return firstPositional && subCommands.includes(firstPositional)
+        ? args
+        : __spreadArray(__spreadArray(__spreadArray([], __read(args.slice(0, 3)), false), ['find'], false), __read(args.slice(3)), false);
+};
 var examples = [
     {
         command: 'sasjs lint',
         description: 'Lints all .sas files in the current project.\n' +
             'All the exceptions (along with line / column numbers) will be shown in the console.'
     },
+    {
+        command: 'sasjs lint --fail-on warning',
+        description: 'Lints all .sas files in the current project and fails on a warning as well as an error.\n' +
+            'The same can be set for every run by adding `"default": "error"` to `severityLevel` in `.sasjslint`.'
+    },
     {
         command: 'sasjs lint find mf_a mf_b',
         description: 'Lints all .sas files starting from mf_a or mf_b in the current project.\n' +
@@ -109,23 +154,32 @@ var examples = [
 var LintCommand = /** @class */ (function (_super) {
     __extends(LintCommand, _super);
     function LintCommand(args) {
-        if (args.length < 4) {
-            args.splice(3, 0, 'find');
-        }
-        return _super.call(this, args, {
+        return _super.call(this, withDefaultSubCommand(args), {
             syntax: syntax,
             usage: usage,
             description: description,
-            examples: examples
+            examples: examples,
+            parseOptions: {
+                'fail-on': {
+                    type: 'string',
+                    description: "Lowest severity that fails the command: ".concat(failOnValues.join(', '), ". Defaults to error, so a warning is reported without failing. Applies to the report run, not to lint fix.")
+                }
+            }
         }) || this;
     }
     LintCommand.prototype.execute = function () {
         return __awaiter(this, void 0, void 0, function () {
-            var _a, subCommand, filterStrings;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
+            var _a, subCommand, filterStrings, failOn, failOnSeverity;
+            var _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
                     case 0:
-                        _a = this.parsed, subCommand = _a.subCommand, filterStrings = _a.filterStrings;
+                        _a = this.parsed, subCommand = _a.subCommand, filterStrings = _a.filterStrings, failOn = _a.failOn;
+                        if (failOn !== undefined && !failOnValues.includes(failOn)) {
+                            (0, utils_1.displayError)(new Error("Invalid value for --fail-on: ".concat(failOn, ". Use one of ").concat(failOnValues.join(', '), ".")));
+                            return [2 /*return*/, command_1.ReturnCode.InvalidCommand];
+                        }
+                        failOnSeverity = (_b = failOn) !== null && _b !== void 0 ? _b : 'error';
                         if (!(subCommand === 'init')) return [3 /*break*/, 2];
                         return [4 /*yield*/, (0, initLint_1.initLint)()
                                 .then(function (res) {
@@ -139,7 +193,7 @@ var LintCommand = /** @class */ (function (_super) {
                                 (0, utils_1.displayError)(err, 'An error has occurred whilst initialising SASjs Lint.');
                                 return command_1.ReturnCode.InternalError;
                             })];
-                    case 1: return [2 /*return*/, _b.sent()];
+                    case 1: return [2 /*return*/, _c.sent()];
                     case 2:
                         if (!(subCommand === 'fix')) return [3 /*break*/, 4];
                         return [4 /*yield*/, (0, processLint_1.lintFix)(filterStrings)
@@ -148,13 +202,20 @@ var LintCommand = /** @class */ (function (_super) {
                                 (0, utils_1.displayError)(err, 'An error has occurred while running SASjs Lint Fix.');
                                 return command_1.ReturnCode.LintError;
                             })];
-                    case 3: return [2 /*return*/, _b.sent()];
+                    case 3: return [2 /*return*/, _c.sent()];
                     case 4: return [4 /*yield*/, (0, processLint_1.processLint)(filterStrings)
                             .then(function (result) {
                             if (result.errors) {
                                 (0, utils_1.displayError)('Please fix the identified lint errors.');
                                 return command_1.ReturnCode.LintError;
                             }
+                            if (result.warnings && failOnSeverity === 'warning') {
+                                var count = result.warningCount;
+                                (0, utils_1.displayError)(count === 1
+                                    ? '1 lint warning treated as an error because of --fail-on warning. Please fix it.'
+                                    : "".concat(count, " lint warnings treated as errors because of --fail-on warning. Please fix them."));
+                                return command_1.ReturnCode.LintError;
+                            }
                             if (result.warnings) {
                                 process.logger.warn('Please fix the identified lint warnings.');
                                 return command_1.ReturnCode.Success;
@@ -166,7 +227,7 @@ var LintCommand = /** @class */ (function (_super) {
                             (0, utils_1.displayError)(err, 'An error has occurred when processing lint operation.');
                             return command_1.ReturnCode.InternalError;
                         })];
-                    case 5: return [2 /*return*/, _b.sent()];
+                    case 5: return [2 /*return*/, _c.sent()];
                 }
             });
         });

package/build/commands/lint/processLint.d.ts

@@ -1,6 +1,10 @@
 interface LintResult {
     warnings: boolean;
     errors: boolean;
+    /** Number of WARNING diagnostics found, across every linted file. */
+    warningCount: number;
+    /** Number of ERROR diagnostics found, across every linted file. */
+    errorCount: number;
 }
 /**
  * Fixes lint violations in all .sas files in the current project if no filterArray is provided

package/build/commands/lint/processLint.js

@@ -70,6 +70,12 @@ var path_1 = __importDefault(require("path"));
 var chalk_1 = __importDefault(require("chalk"));
 var lint_1 = require("@sasjs/lint");
 var utils_1 = require("@sasjs/utils");
+/**
+ * `sasjs lint` is documented to work without a `sasjsconfig.json`, and loading
+ * that file is the only thing that sets `process.projectDir` - so a filter
+ * string is resolved against the current directory when no project was loaded.
+ */
+var getProjectDir = function () { return process.projectDir || process.cwd(); };
 /**
  * Fixes lint violations in all .sas files in the current project if no filterArray is provided
  * Otherwise fixes lint violations of only those .sas files which matches filter array
@@ -125,7 +131,7 @@ function lintFix() {
                         .map(function (pattern) { return "(".concat(pattern, ")"); })
                         .join('|');
                     regex_1 = new RegExp(regexPattern);
-                    return [4 /*yield*/, (0, utils_1.listSasFilesInFolder)(process.projectDir, true, [
+                    return [4 /*yield*/, (0, utils_1.listSasFilesInFolder)(getProjectDir(), true, [
                             'node_modules'
                         ])];
                 case 2:
@@ -194,7 +200,12 @@ function processLint() {
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
-                    found = { warnings: false, errors: false };
+                    found = {
+                        warnings: false,
+                        errors: false,
+                        warningCount: 0,
+                        errorCount: 0
+                    };
                     sasjsDiagnosticsMap = new Map();
                     if (!filterArray.length) return [3 /*break*/, 5];
                     absoluteFilePaths = filterArray.filter(function (pattern) {
@@ -226,7 +237,7 @@ function processLint() {
                         .map(function (pattern) { return "(".concat(pattern, ")"); })
                         .join('|');
                     regex_2 = new RegExp(regexPattern);
-                    return [4 /*yield*/, (0, utils_1.listSasFilesInFolder)(process.projectDir, true, [
+                    return [4 /*yield*/, (0, utils_1.listSasFilesInFolder)(getProjectDir(), true, [
                             'node_modules'
                         ])];
                 case 2:
@@ -237,7 +248,7 @@ function processLint() {
                             return __generator(this, function (_d) {
                                 switch (_d.label) {
                                     case 0:
-                                        filePath = path_1.default.join(process.projectDir, file);
+                                        filePath = path_1.default.join(getProjectDir(), file);
                                         _b = (_a = sasjsDiagnosticsMap).set;
                                         _c = [filePath];
                                         return [4 /*yield*/, (0, lint_1.lintFile)(filePath)];
@@ -258,12 +269,10 @@ function processLint() {
                     _a.label = 7;
                 case 7:
                     sasjsDiagnosticsMap.forEach(function (sasjsDiagnostics, filePath) {
-                        found.warnings =
-                            found.warnings ||
-                                !!sasjsDiagnostics.find(function (d) { return d.severity === lint_1.Severity.Warning; });
-                        found.errors =
-                            found.errors ||
-                                !!sasjsDiagnostics.find(function (d) { return d.severity === lint_1.Severity.Error; });
+                        found.warningCount += sasjsDiagnostics.filter(function (d) { return d.severity === lint_1.Severity.Warning; }).length;
+                        found.errorCount += sasjsDiagnostics.filter(function (d) { return d.severity === lint_1.Severity.Error; }).length;
+                        found.warnings = found.warnings || found.warningCount > 0;
+                        found.errors = found.errors || found.errorCount > 0;
                         if (sasjsDiagnostics.length) {
                             displayDiagnostics(filePath, sasjsDiagnostics);
                         }

package/build/commands/lint/spec/lintCommand.spec.js

@@ -138,10 +138,13 @@ describe('LintCommand', function () {
             switch (_a.label) {
                 case 0:
                     args = __spreadArray(__spreadArray([], __read(defaultArgs), false), ['lint'], false);
-                    jest
-                        .spyOn(processModule, 'processLint')
-                        .mockImplementation(function () {
-                        return Promise.resolve({ warnings: true, errors: false });
+                    jest.spyOn(processModule, 'processLint').mockImplementation(function () {
+                        return Promise.resolve({
+                            warnings: true,
+                            errors: false,
+                            warningCount: 3,
+                            errorCount: 0
+                        });
                     });
                     command = new lintCommand_1.LintCommand(args);
                     return [4 /*yield*/, command.execute()];
@@ -178,10 +181,13 @@ describe('LintCommand', function () {
             switch (_a.label) {
                 case 0:
                     args = __spreadArray(__spreadArray([], __read(defaultArgs), false), ['lint'], false);
-                    jest
-                        .spyOn(processModule, 'processLint')
-                        .mockImplementation(function () {
-                        return Promise.resolve({ warnings: false, errors: true });
+                    jest.spyOn(processModule, 'processLint').mockImplementation(function () {
+                        return Promise.resolve({
+                            warnings: false,
+                            errors: true,
+                            warningCount: 0,
+                            errorCount: 1
+                        });
                     });
                     command = new lintCommand_1.LintCommand(args);
                     return [4 /*yield*/, command.execute()];
@@ -193,6 +199,111 @@ describe('LintCommand', function () {
             }
         });
     }); });
+    it('should default the subcommand when --fail-on comes before the filter', function () {
+        var args = __spreadArray(__spreadArray([], __read(defaultArgs), false), ['lint', '--fail-on', 'warning', 'appinit'], false);
+        var command = new lintCommand_1.LintCommand(args);
+        expect(command.name).toEqual('lint');
+        expect(command.subCommand).toEqual('find');
+    });
+    it('should default the subcommand when only --fail-on is given', function () {
+        var args = __spreadArray(__spreadArray([], __read(defaultArgs), false), ['lint', '--fail-on=warning'], false);
+        var command = new lintCommand_1.LintCommand(args);
+        expect(command.name).toEqual('lint');
+        expect(command.subCommand).toEqual('find');
+    });
+    it('should keep an explicit subcommand ahead of --fail-on', function () {
+        var args = __spreadArray(__spreadArray([], __read(defaultArgs), false), ['lint', 'find', '--fail-on', 'warning'], false);
+        var command = new lintCommand_1.LintCommand(args);
+        expect(command.subCommand).toEqual('find');
+    });
+    it('should fail on warnings when --fail-on warning is passed', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var args, command, returnCode;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    args = __spreadArray(__spreadArray([], __read(defaultArgs), false), ['lint', '--fail-on', 'warning'], false);
+                    jest.spyOn(processModule, 'processLint').mockImplementation(function () {
+                        return Promise.resolve({
+                            warnings: true,
+                            errors: false,
+                            warningCount: 2,
+                            errorCount: 0
+                        });
+                    });
+                    command = new lintCommand_1.LintCommand(args);
+                    return [4 /*yield*/, command.execute()];
+                case 1:
+                    returnCode = _a.sent();
+                    expect(returnCode).toEqual(command_1.ReturnCode.LintError);
+                    expect(process.logger.error).toHaveBeenCalledWith('', '2 lint warnings treated as errors because of --fail-on warning. Please fix them.');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('should word a single warning as one error', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var args, command, returnCode;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    args = __spreadArray(__spreadArray([], __read(defaultArgs), false), ['lint', '--fail-on', 'warning'], false);
+                    jest.spyOn(processModule, 'processLint').mockImplementation(function () {
+                        return Promise.resolve({
+                            warnings: true,
+                            errors: false,
+                            warningCount: 1,
+                            errorCount: 0
+                        });
+                    });
+                    command = new lintCommand_1.LintCommand(args);
+                    return [4 /*yield*/, command.execute()];
+                case 1:
+                    returnCode = _a.sent();
+                    expect(returnCode).toEqual(command_1.ReturnCode.LintError);
+                    expect(process.logger.error).toHaveBeenCalledWith('', '1 lint warning treated as an error because of --fail-on warning. Please fix it.');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('should not fail on warnings when --fail-on error is passed', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var args, command, returnCode;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    args = __spreadArray(__spreadArray([], __read(defaultArgs), false), ['lint', '--fail-on', 'error'], false);
+                    jest.spyOn(processModule, 'processLint').mockImplementation(function () {
+                        return Promise.resolve({
+                            warnings: true,
+                            errors: false,
+                            warningCount: 2,
+                            errorCount: 0
+                        });
+                    });
+                    command = new lintCommand_1.LintCommand(args);
+                    return [4 /*yield*/, command.execute()];
+                case 1:
+                    returnCode = _a.sent();
+                    expect(returnCode).toEqual(command_1.ReturnCode.Success);
+                    expect(process.logger.warn).toHaveBeenCalled();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('should reject an unknown --fail-on value', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var args, command, returnCode;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    args = __spreadArray(__spreadArray([], __read(defaultArgs), false), ['lint', '--fail-on', 'note'], false);
+                    command = new lintCommand_1.LintCommand(args);
+                    return [4 /*yield*/, command.execute()];
+                case 1:
+                    returnCode = _a.sent();
+                    expect(returnCode).toEqual(command_1.ReturnCode.InvalidCommand);
+                    expect(processModule.processLint).not.toHaveBeenCalled();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
 });
 describe('LintCommand - fix', function () {
     beforeEach(function () {
@@ -295,10 +406,13 @@ var setupMocks = function () {
     jest.resetAllMocks();
     jest.mock('../processLint');
     jest.mock('../initLint');
-    jest
-        .spyOn(processModule, 'processLint')
-        .mockImplementation(function () {
-        return Promise.resolve({ warnings: false, errors: false });
+    jest.spyOn(processModule, 'processLint').mockImplementation(function () {
+        return Promise.resolve({
+            warnings: false,
+            errors: false,
+            warningCount: 0,
+            errorCount: 0
+        });
     });
     jest
         .spyOn(processModule, 'lintFix')

package/build/commands/lint/spec/processLint.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/build/commands/lint/spec/processLint.spec.js

@@ -0,0 +1,127 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var fs_1 = __importDefault(require("fs"));
+var os_1 = __importDefault(require("os"));
+var path_1 = __importDefault(require("path"));
+var processLint_1 = require("../processLint");
+/**
+ * `sasjs lint` is documented to run without a `sasjsconfig.json`, and loading
+ * that file is the only thing that sets `process.projectDir` - so these cases
+ * run with it empty, the way a project directory without a config does.
+ */
+describe('processLint', function () {
+    var originalCwd = process.cwd();
+    var tmpDir;
+    beforeEach(function () {
+        tmpDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'sasjs-lint-'));
+        fs_1.default.writeFileSync(path_1.default.join(tmpDir, 'trailing.sas'), "%put 'hello';  \n");
+        process.chdir(tmpDir);
+        process.projectDir = '';
+    });
+    afterEach(function () {
+        process.chdir(originalCwd);
+        process.projectDir = '';
+        fs_1.default.rmSync(tmpDir, { recursive: true, force: true });
+    });
+    it('should resolve a filter string against the current directory when no project is loaded', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var result;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, (0, processLint_1.processLint)(['trailing'])];
+                case 1:
+                    result = _a.sent();
+                    expect(result.warnings).toEqual(true);
+                    expect(result.warningCount).toBeGreaterThan(0);
+                    expect(result.errors).toEqual(false);
+                    expect(result.errorCount).toEqual(0);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('should still accept an absolute path when no project is loaded', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var result;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, (0, processLint_1.processLint)([path_1.default.join(tmpDir, 'trailing.sas')])];
+                case 1:
+                    result = _a.sent();
+                    expect(result.warningCount).toBeGreaterThan(0);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('should report no findings when the filter matches nothing', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var result;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, (0, processLint_1.processLint)(['no-such-file'])];
+                case 1:
+                    result = _a.sent();
+                    expect(result).toEqual({
+                        warnings: false,
+                        errors: false,
+                        warningCount: 0,
+                        errorCount: 0
+                    });
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('should count errors separately from warnings', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var result;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    fs_1.default.writeFileSync(path_1.default.join(tmpDir, 'password.sas'), "%put '{SASENC}';  \n");
+                    return [4 /*yield*/, (0, processLint_1.processLint)(['password'])];
+                case 1:
+                    result = _a.sent();
+                    expect(result.errorCount).toBe(1);
+                    expect(result.errors).toEqual(true);
+                    // The trailing spaces and the missing header are both warnings, so the
+                    // counts stay independent of the error.
+                    expect(result.warningCount).toBeGreaterThanOrEqual(1);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+});

package/build/commands/logcheck/logcheckCommand.js

@@ -115,7 +115,7 @@ var LogCheckCommand = /** @class */ (function (_super) {
                 },
                 'ignore-path': {
                     type: 'array',
-                    description: 'Log path to leave out, as a substring or a glob. Repeatable.'
+                    description: 'Log path to leave out, as a path segment or a glob. A non-glob entry matches whole segments only, so `test` covers `test/run.log` but not `latest.log`. Repeatable.'
                 },
                 format: {
                     type: 'string',

package/build/commands/logcheck/types.d.ts

@@ -32,8 +32,10 @@ export interface LogCheckConfig {
      */
     ignoreCodes: string[];
     /**
-     * Log paths to leave out, as a plain substring (`sasjsresults/legacy`) or a
+     * Log paths to leave out, as a path segment (`sasjsresults/legacy`) or a
      * glob (`**/build*.log`). Matched against the path shown in the report.
+     * A non-glob entry matches whole segments, so `test` covers `test/run.log`
+     * and not `latest.log`.
      */
     ignorePaths: string[];
     /**

package/build/types/command/parse.d.ts

@@ -1,8 +1,29 @@
 import { CommandBase } from './commandBase';
 /**
- * Rewrites a version flag in the command position to the `version` command.
+ * Rewrites a version or help flag in the command position to the command it
+ * stands for.
  *
- * @param args - the process arguments, as `[node, sasjs, ...]`.
+ * @param args - the process arguments, as `[node, sasjs, ...]`
  */
 export declare const normaliseArgs: (args: string[]) => string[];
-export declare const parse: (args: string[]) => CommandBase;
+/**
+ * Resolves the arguments to the command that will run them.
+ *
+ * @param args - the process arguments, as `[node, sasjs, ...]`
+ * @returns the command, or `undefined` when the arguments name no command the
+ * CLI registers. Printing the help and choosing the exit code is the caller's
+ * job, so this stays a pure lookup.
+ */
+export declare const parse: (args: string[]) => CommandBase | undefined;
+/**
+ * The command name the arguments asked for, as typed - so a message can repeat
+ * it back. Empty when no command was given at all.
+ *
+ * @param args - the process arguments, as `[node, sasjs, ...]`
+ */
+export declare const requestedCommandName: (args: string[]) => string;
+/**
+ * Every command the CLI registers, so a misspelling can be answered with the
+ * list rather than a pointer to another command.
+ */
+export declare const commandNames: () => string[];

package/build/types/command/parse.js

@@ -25,33 +25,61 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     return to.concat(ar || Array.prototype.slice.call(from));
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parse = exports.normaliseArgs = void 0;
+exports.commandNames = exports.requestedCommandName = exports.parse = exports.normaliseArgs = void 0;
 var getBaseCommand_1 = require("../../utils/getBaseCommand");
 var commandFactory_1 = require("./commandFactory");
 // `sasjs version`, `sasjs v`, `sasjs -v` and `sasjs --version` all mean the
 // same thing. yargs reads a leading `-v`/`--version` as an option rather than
 // a command, and its own version handling is switched off, so the token is
-// rewritten to the command name before dispatch.
+// rewritten to the command name before dispatch. The help flags get the same
+// treatment: `sasjs --help` is the first thing most people try, and letting it
+// fall through made the root answer "Invalid SASjs command: --help".
 var versionFlags = ['-v', '--version'];
+var helpFlags = ['-h', '--help'];
 /**
- * Rewrites a version flag in the command position to the `version` command.
+ * Rewrites a version or help flag in the command position to the command it
+ * stands for.
  *
- * @param args - the process arguments, as `[node, sasjs, ...]`.
+ * @param args - the process arguments, as `[node, sasjs, ...]`
  */
 var normaliseArgs = function (args) {
     var _a = __read(args, 3), command = _a[2];
-    return versionFlags.includes(command)
-        ? __spreadArray(__spreadArray(__spreadArray([], __read(args.slice(0, 2)), false), ['version'], false), __read(args.slice(3)), false) : args;
+    if (versionFlags.includes(command)) {
+        return __spreadArray(__spreadArray(__spreadArray([], __read(args.slice(0, 2)), false), ['version'], false), __read(args.slice(3)), false);
+    }
+    if (helpFlags.includes(command)) {
+        return __spreadArray(__spreadArray(__spreadArray([], __read(args.slice(0, 2)), false), ['help'], false), __read(args.slice(3)), false);
+    }
+    return args;
 };
 exports.normaliseArgs = normaliseArgs;
+/**
+ * Resolves the arguments to the command that will run them.
+ *
+ * @param args - the process arguments, as `[node, sasjs, ...]`
+ * @returns the command, or `undefined` when the arguments name no command the
+ * CLI registers. Printing the help and choosing the exit code is the caller's
+ * job, so this stays a pure lookup.
+ */
 var parse = function (args) {
-    var _a;
     var commandArgs = (0, exports.normaliseArgs)(args);
     var baseCommand = (0, getBaseCommand_1.getBaseCommand)(commandArgs);
-    if (!Array.from(commandFactory_1.commandFactory.keys()).includes(baseCommand.name)) {
-        (_a = process.logger) === null || _a === void 0 ? void 0 : _a.error('Invalid SASjs command! Run `sasjs help` for a full list of available commands.');
-        process.exit(1);
-    }
-    return commandFactory_1.commandFactory.get(baseCommand.name)(commandArgs);
+    return commandFactory_1.commandFactory.has(baseCommand.name)
+        ? commandFactory_1.commandFactory.get(baseCommand.name)(commandArgs)
+        : undefined;
 };
 exports.parse = parse;
+/**
+ * The command name the arguments asked for, as typed - so a message can repeat
+ * it back. Empty when no command was given at all.
+ *
+ * @param args - the process arguments, as `[node, sasjs, ...]`
+ */
+var requestedCommandName = function (args) { var _a; return (_a = (0, exports.normaliseArgs)(args)[2]) !== null && _a !== void 0 ? _a : ''; };
+exports.requestedCommandName = requestedCommandName;
+/**
+ * Every command the CLI registers, so a misspelling can be answered with the
+ * list rather than a pointer to another command.
+ */
+var commandNames = function () { return Array.from(commandFactory_1.commandFactory.keys()); };
+exports.commandNames = commandNames;

package/build/types/command/spec/parse.spec.js

@@ -8,10 +8,31 @@ describe('parse', function () {
         expect(command).toBeInstanceOf(versionCommand_1.VersionCommand);
         expect(command.name).toEqual('version');
     });
+    it.each(['help', '-h', '--help'])('resolves `sasjs %s` to the help command', function (token) {
+        var command = (0, parse_1.parse)(['node', 'sasjs', token]);
+        expect(command.name).toEqual('help');
+    });
     it('leaves another command as it is', function () {
         var command = (0, parse_1.parse)(['node', 'sasjs', 'help']);
         expect(command.name).toEqual('help');
     });
+    it('returns undefined for a command it does not register', function () {
+        expect((0, parse_1.parse)(['node', 'sasjs', 'frobnicate'])).toBeUndefined();
+    });
+    it('returns undefined when no command is given', function () {
+        expect((0, parse_1.parse)(['node', 'sasjs'])).toBeUndefined();
+    });
+});
+describe('requestedCommandName', function () {
+    it('reports the command as typed', function () {
+        expect((0, parse_1.requestedCommandName)(['node', 'sasjs', 'frobnicate'])).toEqual('frobnicate');
+    });
+    it('reports the version command for a version flag', function () {
+        expect((0, parse_1.requestedCommandName)(['node', 'sasjs', '--version'])).toEqual('version');
+    });
+    it('reports an empty name when there is no command', function () {
+        expect((0, parse_1.requestedCommandName)(['node', 'sasjs'])).toEqual('');
+    });
 });
 describe('normaliseArgs', function () {
     it.each(['-v', '--version'])('rewrites %s in the command position', function (flag) {
@@ -21,6 +42,13 @@ describe('normaliseArgs', function () {
             'version'
         ]);
     });
+    it.each(['-h', '--help'])('rewrites %s in the command position to the help command', function (flag) {
+        expect((0, parse_1.normaliseArgs)(['node', 'sasjs', flag])).toEqual([
+            'node',
+            'sasjs',
+            'help'
+        ]);
+    });
     it('keeps the arguments that follow the flag', function () {
         expect((0, parse_1.normaliseArgs)(['node', 'sasjs', '--version', 'extra'])).toEqual([
             'node',

package/package.json

@@ -73,7 +73,7 @@
     "@sasjs/adapter": "5.1.3",
     "@sasjs/api": "0.23.0",
     "@sasjs/core": "6.1.1",
-    "@sasjs/lint": "5.0.1",
+    "@sasjs/lint": "^5.1.0",
     "@sasjs/utils": "4.9.0",
     "axios": "1.20.0",
     "chalk": "4.1.2",
@@ -125,5 +125,5 @@
     "ws": "8.21.0",
     "nanoid": "3.3.18"
   },
-  "version": "6.20.0"
+  "version": "6.22.0"
 }