@sasjs/cli 6.5.0 → 6.7.0

package/build/commands/logcheck/logCheckConfig.js

@@ -0,0 +1,283 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+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 __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));
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toPosix = exports.globToRegExp = exports.isIgnoredPath = exports.matchesSegments = exports.matchesPath = exports.mergeConfig = exports.readLogCheckConfig = exports.parseLogCheckSection = exports.DEFAULT_FOLDER = exports.CONFIG_KEY = void 0;
+var path_1 = __importDefault(require("path"));
+var utils_1 = require("@sasjs/utils");
+var types_1 = require("./types");
+/** The section of `sasjsconfig.json` this command reads. */
+exports.CONFIG_KEY = 'logCheck';
+/** Folder checked when the command is given no path of its own. */
+exports.DEFAULT_FOLDER = 'sasjsresults';
+var failOnValues = ['error', 'warning', 'note', 'never'];
+/**
+ * Builds a config from an untrusted `logCheck` section.
+ *
+ * Values a user gets wrong are refused rather than ignored: a typo in
+ * `failOn` that silently fell back to the default would leave a gate that
+ * never fails, which is the one failure mode a quality gate must not have.
+ *
+ * @param section - the parsed `logCheck` object from `sasjsconfig.json`.
+ * @param source - the file it came from, named in the error message.
+ */
+var parseLogCheckSection = function (section, source) {
+    if (source === void 0) { source = 'sasjsconfig.json'; }
+    var config = __assign(__assign({}, types_1.defaultLogCheckConfig), { ignoreCodes: [], ignorePaths: [] });
+    if (section === undefined || section === null)
+        return config;
+    if (typeof section !== 'object' || Array.isArray(section)) {
+        throw new Error("The `".concat(exports.CONFIG_KEY, "` property in ").concat(source, " must be an object."));
+    }
+    var _a = section, failOn = _a.failOn, maxWarnings = _a.maxWarnings, ignoreCodes = _a.ignoreCodes, ignorePaths = _a.ignorePaths, folder = _a.folder;
+    if (failOn !== undefined) {
+        if (!failOnValues.includes(failOn)) {
+            throw new Error("The `".concat(exports.CONFIG_KEY, ".failOn` property in ").concat(source, " must be one of ").concat(failOnValues.join(', '), " - received `").concat(String(failOn), "`."));
+        }
+        config.failOn = failOn;
+    }
+    if (maxWarnings !== undefined) {
+        if (typeof maxWarnings !== 'number' ||
+            !Number.isInteger(maxWarnings) ||
+            maxWarnings < 0) {
+            throw new Error("The `".concat(exports.CONFIG_KEY, ".maxWarnings` property in ").concat(source, " must be a whole number of zero or more - received `").concat(String(maxWarnings), "`."));
+        }
+        config.maxWarnings = maxWarnings;
+    }
+    if (ignoreCodes !== undefined) {
+        config.ignoreCodes = stringList(ignoreCodes, "".concat(exports.CONFIG_KEY, ".ignoreCodes"), source);
+    }
+    if (ignorePaths !== undefined) {
+        config.ignorePaths = stringList(ignorePaths, "".concat(exports.CONFIG_KEY, ".ignorePaths"), source);
+    }
+    if (folder !== undefined) {
+        if (typeof folder !== 'string' || !folder.trim()) {
+            throw new Error("The `".concat(exports.CONFIG_KEY, ".folder` property in ").concat(source, " must be a non-empty string."));
+        }
+        config.folder = folder.trim();
+    }
+    return config;
+};
+exports.parseLogCheckSection = parseLogCheckSection;
+/**
+ * Reads the `logCheck` policy from the project's `sasjsconfig.json`.
+ *
+ * A missing file, or one without the section, is not an error - the command
+ * has to work in a folder that is not a SASjs project at all, which is the
+ * whole point of checking a log somebody else produced.
+ */
+var readLogCheckConfig = function () { return __awaiter(void 0, void 0, void 0, function () {
+    var projectDir, configPath, raw, parsed, section, config, resultsFolder;
+    var _a, _b, _c, _d;
+    return __generator(this, function (_e) {
+        switch (_e.label) {
+            case 0:
+                projectDir = process.projectDir || process.cwd();
+                configPath = path_1.default.join(projectDir, 'sasjsconfig.json');
+                return [4 /*yield*/, (0, utils_1.readFile)(configPath).catch(function () { return undefined; })];
+            case 1:
+                raw = _e.sent();
+                if (!raw)
+                    return [2 /*return*/, __assign(__assign({}, types_1.defaultLogCheckConfig), { ignoreCodes: [], ignorePaths: [] })];
+                try {
+                    parsed = JSON.parse(raw);
+                }
+                catch (error) {
+                    throw new Error("Could not parse ".concat(configPath, ": ").concat(error.message));
+                }
+                section = (_b = (_a = parsed === null || parsed === void 0 ? void 0 : parsed.config) === null || _a === void 0 ? void 0 : _a[exports.CONFIG_KEY]) !== null && _b !== void 0 ? _b : parsed === null || parsed === void 0 ? void 0 : parsed[exports.CONFIG_KEY];
+                config = (0, exports.parseLogCheckSection)(section, configPath);
+                // A project may have moved its results folder; the bare command follows it,
+                // unless the logCheck section names a folder of its own.
+                if (!config.folder) {
+                    resultsFolder = (_d = (_c = parsed === null || parsed === void 0 ? void 0 : parsed.config) === null || _c === void 0 ? void 0 : _c.sasjsResultsFolder) !== null && _d !== void 0 ? _d : parsed === null || parsed === void 0 ? void 0 : parsed.sasjsResultsFolder;
+                    if (typeof resultsFolder === 'string' && resultsFolder.trim()) {
+                        config.folder = resultsFolder.trim();
+                    }
+                }
+                return [2 /*return*/, config];
+        }
+    });
+}); };
+exports.readLogCheckConfig = readLogCheckConfig;
+/**
+ * Layers the command line over the config file. Suppressions are added, never
+ * replaced: a flag silences one more code for one run, it does not un-silence
+ * the codes a team has already agreed to accept.
+ */
+var mergeConfig = function (base, overrides) {
+    var _a, _b;
+    if (overrides === void 0) { overrides = {}; }
+    var merged = __assign(__assign({}, base), { ignoreCodes: __spreadArray([], __read(base.ignoreCodes), false), ignorePaths: __spreadArray([], __read(base.ignorePaths), false) });
+    if (overrides.failOn !== undefined) {
+        merged.failOn = overrides.failOn;
+    }
+    if (overrides.maxWarnings !== undefined) {
+        merged.maxWarnings = overrides.maxWarnings;
+    }
+    if ((_a = overrides.ignoreCodes) === null || _a === void 0 ? void 0 : _a.length) {
+        merged.ignoreCodes = unique(__spreadArray(__spreadArray([], __read(merged.ignoreCodes), false), __read(overrides.ignoreCodes), false));
+    }
+    if ((_b = overrides.ignorePaths) === null || _b === void 0 ? void 0 : _b.length) {
+        merged.ignorePaths = unique(__spreadArray(__spreadArray([], __read(merged.ignorePaths), false), __read(overrides.ignorePaths), false));
+    }
+    return merged;
+};
+exports.mergeConfig = mergeConfig;
+/**
+ * Whether a log path is excluded by one of the `ignorePaths` entries.
+ *
+ * An entry with no wildcard is matched against whole path segments, not as a
+ * bare substring of the text: `test` covers `test/run.log` and
+ * `sasjsresults/test/run.log`, but not `latest.log`, and `logs` does not cover
+ * `nested-logs/x.log`. A suppression rule that quietly covers files the author
+ * did not name is the failure mode this whole config guards against, so an
+ * entry has to name a path, not a fragment of one.
+ *
+ * An entry with a wildcard is a glob over the display path, anchored at both
+ * ends, where `**&#47;` crosses folders and `*` does not.
+ */
+var matchesPath = function (displayPath, pattern) {
+    var subject = (0, exports.toPosix)(displayPath);
+    var candidate = normalisePattern((0, exports.toPosix)(pattern));
+    if (!candidate)
+        return false;
+    if (!candidate.includes('*') && !candidate.includes('?')) {
+        return (0, exports.matchesSegments)(subject, candidate);
+    }
+    return (0, exports.globToRegExp)(candidate).test(subject);
+};
+exports.matchesPath = matchesPath;
+/**
+ * A non-glob entry matches when it names the path itself, or a run of whole
+ * segments inside it.
+ *
+ * Padding both sides with a separator makes one `includes` do the work: the
+ * needle can only be found where it begins at a segment boundary and ends at
+ * one, which is exactly the difference between `test` and `latest`.
+ */
+var matchesSegments = function (subject, candidate) {
+    var haystack = "/".concat(stripSlashes(subject), "/");
+    var needle = "/".concat(stripSlashes(candidate), "/");
+    return haystack.includes(needle);
+};
+exports.matchesSegments = matchesSegments;
+var isIgnoredPath = function (displayPath, patterns) { return patterns.some(function (pattern) { return (0, exports.matchesPath)(displayPath, pattern); }); };
+exports.isIgnoredPath = isIgnoredPath;
+/**
+ * Compiles a glob into an expression anchored at both ends.
+ *
+ * `**&#47;` at the start matches zero or more leading folders so that
+ * `**&#47;build.log` covers `build.log` in the project folder as well as one
+ * several folders down - a pattern that only matched the deep case would make
+ * the obvious spelling useless.
+ */
+var globToRegExp = function (pattern) {
+    var source = pattern
+        .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+        .replace(/\*\*\//g, '\u0000')
+        .replace(/\*\*/g, '\u0001')
+        .replace(/\*/g, '[^/]*')
+        .replace(/\?/g, '[^/]')
+        .replace(/\u0000/g, '(?:.*/)?')
+        .replace(/\u0001/g, '.*');
+    return new RegExp("^".concat(source, "$"));
+};
+exports.globToRegExp = globToRegExp;
+/** Path text as it appears in a report: forward slashes, no wrapping quotes. */
+var toPosix = function (value) {
+    return value.split(path_1.default.sep).join('/');
+};
+exports.toPosix = toPosix;
+/**
+ * A suppression entry as it is compared: no `./` lead-in, no trailing
+ * separators, so `./logs/` and `logs` are one entry rather than two.
+ */
+var normalisePattern = function (value) {
+    return stripSlashes(value.trim().replace(/^(?:\.\/)+/, ''));
+};
+var stripSlashes = function (value) {
+    return value.replace(/^\/+/, '').replace(/\/+$/, '');
+};
+var stringList = function (value, name, source) {
+    if (!Array.isArray(value) || value.some(function (item) { return typeof item !== 'string'; })) {
+        throw new Error("The `".concat(name, "` property in ").concat(source, " must be an array of strings."));
+    }
+    return unique(value);
+};
+var unique = function (values) {
+    return Array.from(new Set(values.map(function (value) { return value.trim(); }).filter(Boolean)));
+};

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

@@ -0,0 +1,6 @@
+import { ReturnCode } from '../../types/command';
+import { CommandBase } from '../../types';
+export declare class LogCheckCommand extends CommandBase {
+    constructor(args: string[]);
+    execute(): Promise<ReturnCode.Success | ReturnCode.InvalidCommand | ReturnCode.InternalError | ReturnCode.LogCheckError>;
+}

package/build/commands/logcheck/logcheckCommand.js

@@ -0,0 +1,200 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+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 };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogCheckCommand = void 0;
+var command_1 = require("../../types/command");
+var types_1 = require("../../types");
+var utils_1 = require("../../utils");
+var logCheckConfig_1 = require("./logCheckConfig");
+var processLogCheck_1 = require("./processLogCheck");
+var renderLogCheck_1 = require("./renderLogCheck");
+var failOnValues = ['error', 'warning', 'note', 'never'];
+var formats = ['human', 'json', 'annotations'];
+var syntax = 'logcheck [paths..]';
+var aliases = ['lc'];
+var usage = 'sasjs logcheck [path..] [--fail-on error|warning|note|never] [--format human|json|annotations]';
+var description = "Checks SAS logs for what SAS itself printed - ERRORs, WARNINGs and the notes that flag a problem - and fails when the failure policy is broken.\n" +
+    "With no path, the results folder of the current project is checked, which is where run, job and test leave their logs.\n" +
+    "No target, no login and no project are needed: a log from Enterprise Guide, or from a server somewhere else, checks the same way.";
+var examples = [
+    {
+        command: 'sasjs logcheck',
+        description: "Checks every log in the project's sasjsresults folder and fails on any ERROR."
+    },
+    {
+        command: 'sasjs logcheck ./logs',
+        description: 'Checks every file under ./logs, skipping the ones that are not SAS logs.'
+    },
+    {
+        command: 'sasjs logcheck run.log --fail-on warning',
+        description: 'Checks one log, and fails on a WARNING as well as an ERROR.'
+    },
+    {
+        command: 'sasjs logcheck --max-warnings 10',
+        description: 'Fails when the checked logs carry more than ten warnings in total.'
+    },
+    {
+        command: 'sasjs logcheck --ignore-code 49-169',
+        description: 'Reports everything except the notes carrying the SAS message code 49-169.'
+    },
+    {
+        command: 'sasjs logcheck --format json',
+        description: 'Prints the result as JSON, for a pipeline to read.'
+    },
+    {
+        command: 'sasjs logcheck --format annotations',
+        description: 'Prints GitHub Actions annotations, underlining each issue in the workflow log.'
+    }
+];
+var LogCheckCommand = /** @class */ (function (_super) {
+    __extends(LogCheckCommand, _super);
+    function LogCheckCommand(args) {
+        return _super.call(this, args, {
+            parseOptions: {
+                'fail-on': {
+                    type: 'string',
+                    description: "Lowest severity that fails the check: ".concat(failOnValues.join(', '), ". Defaults to the logCheck.failOn setting in sasjsconfig.json, or error.")
+                },
+                'max-warnings': {
+                    type: 'number',
+                    description: 'Number of warnings tolerated before the check fails, whatever --fail-on says.'
+                },
+                'ignore-code': {
+                    type: 'array',
+                    description: 'SAS message code to suppress, e.g. 49-169. Repeatable, and added to any codes already suppressed in sasjsconfig.json.'
+                },
+                'ignore-path': {
+                    type: 'array',
+                    description: 'Log path to leave out, as a substring or a glob. Repeatable.'
+                },
+                format: {
+                    type: 'string',
+                    default: 'human',
+                    description: "How to print the result: ".concat(formats.join(', '), ". Defaults to human.")
+                },
+                json: {
+                    type: 'boolean',
+                    default: false,
+                    description: 'Shorthand for --format json.'
+                },
+                verbose: {
+                    type: 'boolean',
+                    alias: 'v',
+                    default: false,
+                    description: 'List the files that were skipped, and why.'
+                }
+            },
+            syntax: syntax,
+            aliases: aliases,
+            usage: usage,
+            description: description,
+            examples: examples
+        }) || this;
+    }
+    LogCheckCommand.prototype.execute = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, paths, failOn, maxWarnings, ignoreCode, ignorePath, format, json, verbose, config, _b, summary, error_1;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        _a = this.parsed, paths = _a.paths, failOn = _a.failOn, maxWarnings = _a.maxWarnings, ignoreCode = _a.ignoreCode, ignorePath = _a.ignorePath, format = _a.format, json = _a.json, verbose = _a.verbose;
+                        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];
+                        }
+                        if (format !== undefined && !formats.includes(format)) {
+                            (0, utils_1.displayError)(new Error("Invalid value for --format: ".concat(format, ". Use one of ").concat(formats.join(', '), ".")));
+                            return [2 /*return*/, command_1.ReturnCode.InvalidCommand];
+                        }
+                        _c.label = 1;
+                    case 1:
+                        _c.trys.push([1, 4, , 5]);
+                        _b = logCheckConfig_1.mergeConfig;
+                        return [4 /*yield*/, (0, logCheckConfig_1.readLogCheckConfig)()];
+                    case 2:
+                        config = _b.apply(void 0, [_c.sent(), {
+                                failOn: failOn,
+                                maxWarnings: maxWarnings,
+                                ignoreCodes: toStringArray(ignoreCode),
+                                ignorePaths: toStringArray(ignorePath)
+                            }]);
+                        return [4 /*yield*/, (0, processLogCheck_1.processLogCheck)({
+                                paths: toStringArray(paths),
+                                config: config
+                            })];
+                    case 3:
+                        summary = _c.sent();
+                        (0, renderLogCheck_1.renderLogCheck)(summary, config, {
+                            format: json ? 'json' : format,
+                            verbose: !!verbose
+                        });
+                        return [2 /*return*/, summary.failure ? command_1.ReturnCode.LogCheckError : command_1.ReturnCode.Success];
+                    case 4:
+                        error_1 = _c.sent();
+                        (0, utils_1.displayError)(error_1, 'An error has occurred when checking SAS logs.');
+                        return [2 /*return*/, command_1.ReturnCode.InternalError];
+                    case 5: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return LogCheckCommand;
+}(types_1.CommandBase));
+exports.LogCheckCommand = LogCheckCommand;
+/**
+ * yargs hands back an array for a repeatable option, and nothing at all when it
+ * is not given, so every consumer gets a list.
+ */
+var toStringArray = function (value) {
+    return Array.isArray(value) ? value.map(function (item) { return String(item); }) : [];
+};

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

@@ -0,0 +1,44 @@
+import { LogCheckConfig, LogCheckSummary, ScannedLog } from './types';
+export interface LogCheckOptions {
+    /** Paths named on the command line. Empty means the project's results folder. */
+    paths?: string[];
+    config: LogCheckConfig;
+}
+/**
+ * Runs the check: expands the input, parses every log, applies the policy and
+ * says whether the run passes.
+ *
+ * The report is built here rather than in the renderer so that the three
+ * output formats cannot disagree about what was found - the summary is the
+ * single answer, and human, JSON and CI annotations are three ways of printing
+ * it.
+ */
+export declare const processLogCheck: ({ paths, config }: LogCheckOptions) => Promise<LogCheckSummary>;
+/**
+ * Where a run with no arguments looks. The project's results folder is where
+ * `run`, `job run` and `test` leave their logs, which makes the bare command
+ * do the useful thing inside a project.
+ */
+export declare const defaultInputPath: (config: LogCheckConfig) => string;
+/**
+ * Adds up what the run found. Skipped logs contribute nothing but are counted
+ * so the report can say how many files it passed over.
+ */
+export declare const sumTotals: (scanned: ScannedLog[], fileCount?: number) => LogCheckSummary["totals"];
+/**
+ * The verdict, as a phrase for the report.
+ *
+ * An ERROR always fails unless the policy is `never`; warnings and notes fail
+ * only when the policy asks for them, because notable notes are what legacy
+ * code emits in bulk and a gate that is red on its first run is a gate that
+ * gets commented out.
+ *
+ * A warnings budget is checked first and applies even under `never`: writing
+ * `maxWarnings: 0` is a specific instruction, and a specific instruction
+ * outranks a blanket one. `never` therefore means "do not fail on what you
+ * find", not "ignore the budget I also asked for".
+ *
+ * A path that could not be checked fails the run ahead of everything else: the
+ * answer to "is this log clean" is unknown, and unknown is not a pass.
+ */
+export declare const describeFailure: (totals: LogCheckSummary["totals"], config: LogCheckConfig, missingCount?: number, unreadableCount?: number) => string | undefined;