avo-cli 0.0.3 → 4.2.0.beta.1

data/payload/node_modules/@oclif/core/lib/util/os.js

@@ -0,0 +1,58 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getHomeDir = getHomeDir;
+exports.getPlatform = getPlatform;
+exports.getShell = getShell;
+const node_child_process_1 = require("node:child_process");
+const node_os_1 = require("node:os");
+const node_path_1 = __importDefault(require("node:path"));
+/**
+ * Call os.homedir() and return the result
+ *
+ * Wrapping this allows us to stub these in tests since os.homedir() is
+ * non-configurable and non-writable.
+ *
+ * @returns The user's home directory
+ */
+function getHomeDir() {
+    return (0, node_os_1.homedir)();
+}
+/**
+ * Call os.platform() and return the result
+ *
+ * Wrapping this allows us to stub these in tests since os.platform() is
+ * non-configurable and non-writable.
+ *
+ * @returns The process' platform
+ */
+async function getPlatform() {
+    return (await import('wsl-utils')).isWsl ? 'wsl' : (0, node_os_1.platform)();
+}
+async function getShell() {
+    let shellPath;
+    const SHELL = process.env.SHELL ?? (0, node_os_1.userInfo)().shell?.split(node_path_1.default.sep)?.pop();
+    if (SHELL) {
+        shellPath = SHELL.split('/');
+    }
+    else if ((await getPlatform()) === 'win32') {
+        shellPath = (await determineWindowsShell()).split(node_path_1.default.sep);
+    }
+    else {
+        shellPath = ['unknown'];
+    }
+    return shellPath.at(-1) ?? 'unknown';
+}
+async function determineWindowsShell() {
+    try {
+        const parentProcessName = (0, node_child_process_1.execSync)(`${await (await import('wsl-utils')).powerShellPath()} -NoProfile -Command "(Get-CimInstance Win32_Process -Filter 'ProcessID = ${process.ppid}').Name"`, { encoding: 'utf8' });
+        return parentProcessName.includes('powershell') || parentProcessName.includes('pwsh')
+            ? 'powershell'
+            : (process.env.COMSPEC ?? 'cmd.exe');
+    }
+    catch {
+        return process.env.COMSPEC ?? 'cmd.exe';
+    }
+}

data/payload/node_modules/@oclif/core/lib/util/read-pjson.d.ts

@@ -0,0 +1,7 @@
+import { PJSON } from '../interfaces';
+/**
+ * Read the package.json file from a given path and add the oclif config (found by lilconfig) if it exists.
+ *
+ * We can assume that the package.json file exists because the plugin root has already been loaded at this point.
+ */
+export declare function readPjson(path: string): Promise<PJSON>;

data/payload/node_modules/@oclif/core/lib/util/read-pjson.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readPjson = readPjson;
+const lilconfig_1 = require("lilconfig");
+const node_path_1 = require("node:path");
+const logger_1 = require("../logger");
+const fs_1 = require("./fs");
+const debug = (0, logger_1.makeDebug)('read-pjson');
+/**
+ * Read the package.json file from a given path and add the oclif config (found by lilconfig) if it exists.
+ *
+ * We can assume that the package.json file exists because the plugin root has already been loaded at this point.
+ */
+async function readPjson(path) {
+    const pjsonPath = (0, node_path_1.join)(path, 'package.json');
+    if (process.env.OCLIF_DISABLE_RC) {
+        debug('OCLIF_DISABLE_RC is set, skipping rc search');
+        return (0, fs_1.readJson)(pjsonPath);
+    }
+    const pjson = await (0, fs_1.readJson)(pjsonPath);
+    // don't bother with lilconfig if the plugin's package.json already has an oclif config
+    if (pjson.oclif) {
+        debug(`found oclif config in ${pjsonPath}`);
+        return pjson;
+    }
+    debug(`searching for oclif config in ${path}`);
+    const explorer = (0, lilconfig_1.lilconfig)('oclif', {
+        /**
+         * Remove the following from the defaults:
+         * - package.json
+         * - any files under .config/
+         */
+        searchPlaces: [
+            '.oclifrc',
+            '.oclifrc.json',
+            '.oclifrc.js',
+            '.oclifrc.mjs',
+            '.oclifrc.cjs',
+            'oclif.config.js',
+            'oclif.config.mjs',
+            'oclif.config.cjs',
+        ],
+        stopDir: path,
+    });
+    const result = await explorer.search(path);
+    if (!result?.config) {
+        debug(`no oclif config found in ${path}`);
+        return pjson;
+    }
+    debug(`found oclif config for ${path}: %O`, result);
+    return {
+        ...pjson,
+        oclif: result?.config ?? {},
+    };
+}

data/payload/node_modules/@oclif/core/lib/util/read-tsconfig.d.ts

@@ -0,0 +1,2 @@
+import { TSConfig } from '../interfaces';
+export declare function readTSConfig(root: string, tsconfigName?: string): Promise<TSConfig | undefined>;

data/payload/node_modules/@oclif/core/lib/util/read-tsconfig.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readTSConfig = readTSConfig;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const warn_1 = require("../errors/warn");
+const logger_1 = require("../logger");
+const util_1 = require("./util");
+const debug = (0, logger_1.makeDebug)('read-tsconfig');
+function resolve(root, name) {
+    try {
+        return require.resolve(name, { paths: [root] });
+    }
+    catch {
+        // return undefined
+    }
+}
+async function upUntil(path, test) {
+    let result;
+    try {
+        result = await test(path);
+    }
+    catch {
+        result = false;
+    }
+    if (result)
+        return path;
+    const parent = (0, node_path_1.dirname)(path);
+    if (parent === path)
+        return;
+    return upUntil(parent, test);
+}
+async function readTSConfig(root, tsconfigName = 'tsconfig.json') {
+    const found = [];
+    let typescript;
+    try {
+        typescript = require('typescript');
+    }
+    catch {
+        try {
+            typescript = require(root + '/node_modules/typescript');
+        }
+        catch { }
+    }
+    if (!typescript) {
+        (0, warn_1.memoizedWarn)('Could not find typescript. Please ensure that typescript is a devDependency. Falling back to compiled source.');
+        return;
+    }
+    const read = async (path) => {
+        const localRoot = await upUntil(path, async (p) => (await (0, promises_1.readdir)(p)).includes('package.json'));
+        if (!localRoot)
+            return;
+        try {
+            const contents = await (0, promises_1.readFile)(path, 'utf8');
+            const parsed = typescript?.parseConfigFileTextToJson(path, contents).config;
+            found.push(parsed);
+            if (parsed.extends) {
+                if (parsed.extends.startsWith('.')) {
+                    const nextPath = resolve(localRoot, parsed.extends);
+                    return nextPath ? read(nextPath) : undefined;
+                }
+                const resolved = resolve(localRoot, parsed.extends);
+                if (resolved)
+                    return read(resolved);
+            }
+            return parsed;
+        }
+        catch (error) {
+            debug(error);
+        }
+    };
+    await read((0, node_path_1.join)(root, tsconfigName));
+    return {
+        compilerOptions: (0, util_1.mergeNestedObjects)(found, 'compilerOptions'),
+        'ts-node': (0, util_1.mergeNestedObjects)(found, 'ts-node'),
+    };
+}

data/payload/node_modules/@oclif/core/lib/util/util.d.ts

@@ -0,0 +1,23 @@
+export declare function pickBy<T extends {
+    [s: string]: T[keyof T];
+} | ArrayLike<T[keyof T]>>(obj: T, fn: (i: T[keyof T]) => boolean): Partial<T>;
+export declare function compact<T>(a: (T | undefined)[]): T[];
+export declare function uniqBy<T>(arr: T[], fn: (cur: T) => any): T[];
+export declare function last<T>(arr?: T[]): T | undefined;
+type SortTypes = boolean | number | string | undefined;
+export declare function sortBy<T>(arr: T[], fn: (i: T) => SortTypes | SortTypes[]): T[];
+export declare function castArray<T>(input?: T | T[]): T[];
+export declare function isProd(): boolean;
+export declare function maxBy<T>(arr: T[], fn: (i: T) => number): T | undefined;
+export declare function sumBy<T>(arr: T[], fn: (i: T) => number): number;
+export declare function capitalize(s: string): string;
+export declare function isTruthy(input: string): boolean;
+export declare function isNotFalsy(input: string): boolean;
+export declare function uniq<T>(arr: T[]): T[];
+export declare function mapValues<T extends Record<string, any>, TResult>(obj: {
+    [P in keyof T]: T[P];
+}, fn: (i: T[keyof T], k: keyof T) => TResult): {
+    [P in keyof T]: TResult;
+};
+export declare function mergeNestedObjects(objs: Record<string, any>[], path: string): Record<string, any>;
+export {};

data/payload/node_modules/@oclif/core/lib/util/util.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pickBy = pickBy;
+exports.compact = compact;
+exports.uniqBy = uniqBy;
+exports.last = last;
+exports.sortBy = sortBy;
+exports.castArray = castArray;
+exports.isProd = isProd;
+exports.maxBy = maxBy;
+exports.sumBy = sumBy;
+exports.capitalize = capitalize;
+exports.isTruthy = isTruthy;
+exports.isNotFalsy = isNotFalsy;
+exports.uniq = uniq;
+exports.mapValues = mapValues;
+exports.mergeNestedObjects = mergeNestedObjects;
+function pickBy(obj, fn) {
+    return Object.entries(obj).reduce((o, [k, v]) => {
+        if (fn(v))
+            o[k] = v;
+        return o;
+    }, {});
+}
+function compact(a) {
+    return a.filter((a) => Boolean(a));
+}
+function uniqBy(arr, fn) {
+    return arr.filter((a, i) => {
+        const aVal = fn(a);
+        return !arr.some((b, j) => j > i && fn(b) === aVal);
+    });
+}
+function last(arr) {
+    if (!arr)
+        return;
+    return arr.at(-1);
+}
+function compare(a, b) {
+    a = a === undefined ? 0 : a;
+    b = b === undefined ? 0 : b;
+    if (Array.isArray(a) && Array.isArray(b)) {
+        if (a.length === 0 && b.length === 0)
+            return 0;
+        const diff = compare(a[0], b[0]);
+        if (diff !== 0)
+            return diff;
+        return compare(a.slice(1), b.slice(1));
+    }
+    if (a < b)
+        return -1;
+    if (a > b)
+        return 1;
+    return 0;
+}
+function sortBy(arr, fn) {
+    return arr.sort((a, b) => compare(fn(a), fn(b)));
+}
+function castArray(input) {
+    if (input === undefined)
+        return [];
+    return Array.isArray(input) ? input : [input];
+}
+function isProd() {
+    return !['development', 'test'].includes(process.env.NODE_ENV ?? '');
+}
+function maxBy(arr, fn) {
+    if (arr.length === 0) {
+        return undefined;
+    }
+    return arr.reduce((maxItem, i) => {
+        const curr = fn(i);
+        const max = fn(maxItem);
+        return curr > max ? i : maxItem;
+    });
+}
+function sumBy(arr, fn) {
+    return arr.reduce((sum, i) => sum + fn(i), 0);
+}
+function capitalize(s) {
+    return s ? s.charAt(0).toUpperCase() + s.slice(1).toLowerCase() : '';
+}
+function isTruthy(input) {
+    return ['1', 'true', 'y', 'yes'].includes(input.toLowerCase());
+}
+function isNotFalsy(input) {
+    return !['0', 'false', 'n', 'no'].includes(input.toLowerCase());
+}
+function uniq(arr) {
+    return [...new Set(arr)].sort();
+}
+function mapValues(obj, fn) {
+    return Object.entries(obj).reduce((o, [k, v]) => {
+        o[k] = fn(v, k);
+        return o;
+    }, {});
+}
+function get(obj, path) {
+    return path.split('.').reduce((o, p) => o?.[p], obj);
+}
+function mergeNestedObjects(objs, path) {
+    return Object.fromEntries(objs.flatMap((o) => Object.entries(get(o, path) ?? {})).reverse());
+}

data/payload/node_modules/@oclif/core/lib/ux/action/base.d.ts

@@ -0,0 +1,34 @@
+import { Options } from './types';
+type Task = {
+    action: string;
+    active: boolean;
+    status: string | undefined;
+};
+export type ActionType = 'debug' | 'simple' | 'spinner';
+export declare class ActionBase {
+    std: 'stderr' | 'stdout';
+    protected stdmocks?: ['stderr' | 'stdout', string[]][];
+    type: ActionType;
+    private stdmockOrigs;
+    private get globals();
+    protected get output(): string | undefined;
+    protected set output(output: string | undefined);
+    get running(): boolean;
+    get status(): string | undefined;
+    set status(status: string | undefined);
+    get task(): Task | undefined;
+    set task(task: Task | undefined);
+    protected _flushStdout(): void;
+    protected _pause(_?: string): void;
+    protected _resume(): void;
+    protected _start(_opts: Options): void;
+    protected _stdout(toggle: boolean): void;
+    protected _stop(_: string): void;
+    protected _updateStatus(_: string | undefined, __?: string): void;
+    protected _write(std: 'stderr' | 'stdout', s: string | string[]): void;
+    pause(fn: () => any, icon?: string): Promise<any>;
+    pauseAsync<T>(fn: () => Promise<T>, icon?: string): Promise<T>;
+    start(action: string, status?: string, opts?: Options): void;
+    stop(msg?: string): void;
+}
+export {};

data/payload/node_modules/@oclif/core/lib/ux/action/base.js

@@ -0,0 +1,183 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActionBase = void 0;
+const node_util_1 = require("node:util");
+const util_1 = require("../../util/util");
+class ActionBase {
+    std = 'stderr';
+    stdmocks;
+    type;
+    stdmockOrigs = {
+        stderr: process.stderr.write,
+        stdout: process.stdout.write,
+    };
+    get globals() {
+        ;
+        globalThis.ux = globalThis.ux || {};
+        const globals = globalThis.ux;
+        globals.action = globals.action || {};
+        return globals;
+    }
+    get output() {
+        return this.globals.output;
+    }
+    set output(output) {
+        this.globals.output = output;
+    }
+    get running() {
+        return Boolean(this.task);
+    }
+    get status() {
+        return this.task ? this.task.status : undefined;
+    }
+    set status(status) {
+        const { task } = this;
+        if (!task) {
+            return;
+        }
+        if (task.status === status) {
+            return;
+        }
+        this._updateStatus(status, task.status);
+        task.status = status;
+    }
+    get task() {
+        return this.globals.action.task;
+    }
+    set task(task) {
+        this.globals.action.task = task;
+    }
+    // flush mocked stdout/stderr
+    _flushStdout() {
+        try {
+            let output = '';
+            let std;
+            while (this.stdmocks && this.stdmocks.length > 0) {
+                const cur = this.stdmocks.shift();
+                std = cur[0];
+                this._write(std, cur[1]);
+                output += cur[1][0].toString('utf8');
+            }
+            // add newline if there isn't one already
+            // otherwise we'll just overwrite it when we render
+            if (output && std && output.at(-1) !== '\n') {
+                this._write(std, '\n');
+            }
+        }
+        catch (error) {
+            this._write('stderr', (0, node_util_1.inspect)(error));
+        }
+    }
+    _pause(_) {
+        throw new Error('not implemented');
+    }
+    _resume() {
+        if (this.task)
+            this.start(this.task.action, this.task.status);
+    }
+    _start(_opts) {
+        throw new Error('not implemented');
+    }
+    // mock out stdout/stderr so it doesn't screw up the rendering
+    _stdout(toggle) {
+        try {
+            if (toggle) {
+                if (this.stdmocks)
+                    return;
+                this.stdmockOrigs = {
+                    stderr: process.stderr.write,
+                    stdout: process.stdout.write,
+                };
+                this.stdmocks = [];
+                process.stdout.write = (...args) => {
+                    this.stdmocks.push(['stdout', args]);
+                    return true;
+                };
+                process.stderr.write = (...args) => {
+                    this.stdmocks.push(['stderr', args]);
+                    return true;
+                };
+            }
+            else {
+                if (!this.stdmocks)
+                    return;
+                // this._write('stderr', '\nresetstdmock\n\n\n')
+                delete this.stdmocks;
+                process.stdout.write = this.stdmockOrigs.stdout;
+                process.stderr.write = this.stdmockOrigs.stderr;
+            }
+        }
+        catch (error) {
+            this._write('stderr', (0, node_util_1.inspect)(error));
+        }
+    }
+    _stop(_) {
+        throw new Error('not implemented');
+    }
+    _updateStatus(_, __) {
+        // Not implemented
+    }
+    // write to the real stdout/stderr
+    _write(std, s) {
+        switch (std) {
+            case 'stderr': {
+                this.stdmockOrigs.stderr.apply(process.stderr, (0, util_1.castArray)(s));
+                break;
+            }
+            case 'stdout': {
+                this.stdmockOrigs.stdout.apply(process.stdout, (0, util_1.castArray)(s));
+                break;
+            }
+            default: {
+                throw new Error(`invalid std: ${std}`);
+            }
+        }
+    }
+    pause(fn, icon) {
+        const { task } = this;
+        const active = task && task.active;
+        if (task && active) {
+            this._pause(icon);
+            this._stdout(false);
+            task.active = false;
+        }
+        const ret = fn();
+        if (task && active) {
+            this._resume();
+        }
+        return ret;
+    }
+    async pauseAsync(fn, icon) {
+        const { task } = this;
+        const active = task && task.active;
+        if (task && active) {
+            this._pause(icon);
+            this._stdout(false);
+            task.active = false;
+        }
+        const ret = await fn();
+        if (task && active) {
+            this._resume();
+        }
+        return ret;
+    }
+    start(action, status, opts = {}) {
+        this.std = opts.stdout ? 'stdout' : 'stderr';
+        const task = { action, active: Boolean(this.task && this.task.active), status };
+        this.task = task;
+        this._start(opts);
+        task.active = true;
+        this._stdout(true);
+    }
+    stop(msg = 'done') {
+        const { task } = this;
+        if (!task) {
+            return;
+        }
+        this._stop(msg);
+        task.active = false;
+        this.task = undefined;
+        this._stdout(false);
+    }
+}
+exports.ActionBase = ActionBase;

data/payload/node_modules/@oclif/core/lib/ux/action/simple.d.ts

@@ -0,0 +1,11 @@
+import { ActionBase, ActionType } from './base';
+export default class SimpleAction extends ActionBase {
+    type: ActionType;
+    protected _pause(icon?: string): void;
+    protected _resume(): void;
+    protected _start(): void;
+    protected _stop(status: string): void;
+    protected _updateStatus(status: string, prevStatus?: string, newline?: boolean): void;
+    private _flush;
+    private _render;
+}

data/payload/node_modules/@oclif/core/lib/ux/action/simple.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const base_1 = require("./base");
+class SimpleAction extends base_1.ActionBase {
+    type = 'simple';
+    _pause(icon) {
+        if (icon)
+            this._updateStatus(icon);
+        else
+            this._flush();
+    }
+    _resume() {
+        // Not implemented
+    }
+    _start() {
+        if (!this.task)
+            return;
+        this._render(this.task.action, this.task.status);
+    }
+    _stop(status) {
+        if (!this.task)
+            return;
+        this._updateStatus(status, this.task.status, true);
+    }
+    _updateStatus(status, prevStatus, newline = false) {
+        if (!this.task)
+            return;
+        if (this.task.active && !prevStatus)
+            this._write(this.std, ` ${status}`);
+        else
+            this._write(this.std, `${this.task.action}... ${status}`);
+        if (newline || !prevStatus)
+            this._flush();
+    }
+    _flush() {
+        this._write(this.std, '\n');
+        this._flushStdout();
+    }
+    _render(action, status) {
+        if (!this.task)
+            return;
+        if (this.task.active)
+            this._flush();
+        this._write(this.std, status ? `${action}... ${status}` : `${action}...`);
+    }
+}
+exports.default = SimpleAction;

data/payload/node_modules/@oclif/core/lib/ux/action/spinner.d.ts

@@ -0,0 +1,19 @@
+import { ActionBase, ActionType } from './base';
+import { Options } from './types';
+export default class SpinnerAction extends ActionBase {
+    type: ActionType;
+    private color;
+    private frameIndex;
+    private frames;
+    private spinner?;
+    constructor();
+    protected _frame(): string;
+    protected _pause(icon?: string): void;
+    protected _start(opts: Options): void;
+    protected _stop(status: string): void;
+    protected colorize(s: string): string;
+    private _lines;
+    private _render;
+    private _reset;
+    private getFrames;
+}