avo-cli 0.0.3 → 4.2.0.beta.1

data/payload/node_modules/@inquirer/type/dist/commonjs/utils.d.ts

@@ -0,0 +1,29 @@
+type Key = string | number | symbol;
+export type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+export type PartialDeep<T> = T extends object ? {
+    [P in keyof T]?: PartialDeep<T[P]>;
+} : T;
+export type LiteralUnion<T extends F, F = string> = T | (F & {});
+export type KeyUnion<T> = LiteralUnion<Extract<keyof T, string>>;
+export type DistributiveMerge<A, B> = A extends any ? Prettify<Omit<A, keyof B> & B> : never;
+export type UnionToIntersection<T> = (T extends any ? (input: T) => void : never) extends (input: infer Intersection) => void ? Intersection : never;
+/**
+ * @hidden
+ */
+type __Pick<O extends object, K extends keyof O> = {
+    [P in K]: O[P];
+} & {};
+/**
+ * @hidden
+ */
+export type _Pick<O extends object, K extends Key> = __Pick<O, keyof O & K>;
+/**
+ * Extract out of `O` the fields of key `K`
+ * @param O to extract from
+ * @param K to chose fields
+ * @returns [[Object]]
+ */
+export type Pick<O extends object, K extends Key> = O extends unknown ? _Pick<O, K> : never;
+export {};

data/payload/node_modules/@inquirer/type/dist/commonjs/utils.js

@@ -0,0 +1,3 @@
+"use strict";
+/* eslint-disable @typescript-eslint/no-explicit-any */
+Object.defineProperty(exports, "__esModule", { value: true });

data/payload/node_modules/@inquirer/type/dist/esm/index.d.ts

@@ -0,0 +1,2 @@
+export * from './inquirer.ts';
+export * from './utils.ts';

data/payload/node_modules/@inquirer/type/dist/esm/index.js

@@ -0,0 +1,2 @@
+export * from "./inquirer.js";
+export * from "./utils.js";

data/payload/node_modules/@inquirer/type/dist/esm/inquirer.d.ts

@@ -0,0 +1,38 @@
+import { Duplex } from 'node:stream';
+/**
+ * `InquirerReadline` is a re-implementation of `readline.Interface` from Node.js.
+ * We're reimplementing it because of 3 reasons:
+ * 1. The `readline.Interface` API is not complete; it's missing for example `clearLine`.
+ * 2. The input/output streams are not generics, meaning they're inexact.
+ * 3. Since ReadLine isn't built-in Typescript Global NodeJS type, it'd force us to ship `@types/node` as a dependency to all users.
+ */
+export type InquirerReadline = {
+    output: Duplex & {
+        mute: () => void;
+        unmute: () => void;
+    };
+    input: NodeJS.ReadableStream;
+    clearLine: (dir: 0 | 1 | -1) => void;
+    getCursorPos: () => {
+        rows: number;
+        cols: number;
+    };
+    setPrompt: (prompt: string) => void;
+    line: string;
+    write: (data: string) => void;
+    on: (event: string, listener: (...args: unknown[]) => void) => void;
+    removeListener: (event: string, listener: (...args: unknown[]) => void) => void;
+    pause: () => void;
+    resume: () => void;
+    close: () => void;
+};
+export type Context = {
+    input?: NodeJS.ReadableStream;
+    output?: NodeJS.WritableStream;
+    clearPromptOnDone?: boolean;
+    signal?: AbortSignal;
+};
+export type Prompt<Value, Config> = (config: Config, context?: Context) => Promise<Value> & {
+    /** @deprecated pass an AbortSignal in the context options instead. See {@link https://github.com/SBoudrias/Inquirer.js#canceling-prompt} */
+    cancel: () => void;
+};

data/payload/node_modules/@inquirer/type/dist/esm/inquirer.js

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

data/payload/node_modules/@inquirer/type/dist/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

data/payload/node_modules/@inquirer/type/dist/esm/utils.d.ts

@@ -0,0 +1,29 @@
+type Key = string | number | symbol;
+export type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+export type PartialDeep<T> = T extends object ? {
+    [P in keyof T]?: PartialDeep<T[P]>;
+} : T;
+export type LiteralUnion<T extends F, F = string> = T | (F & {});
+export type KeyUnion<T> = LiteralUnion<Extract<keyof T, string>>;
+export type DistributiveMerge<A, B> = A extends any ? Prettify<Omit<A, keyof B> & B> : never;
+export type UnionToIntersection<T> = (T extends any ? (input: T) => void : never) extends (input: infer Intersection) => void ? Intersection : never;
+/**
+ * @hidden
+ */
+type __Pick<O extends object, K extends keyof O> = {
+    [P in K]: O[P];
+} & {};
+/**
+ * @hidden
+ */
+export type _Pick<O extends object, K extends Key> = __Pick<O, keyof O & K>;
+/**
+ * Extract out of `O` the fields of key `K`
+ * @param O to extract from
+ * @param K to chose fields
+ * @returns [[Object]]
+ */
+export type Pick<O extends object, K extends Key> = O extends unknown ? _Pick<O, K> : never;
+export {};

data/payload/node_modules/@inquirer/type/dist/esm/utils.js

@@ -0,0 +1,2 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+export {};

data/payload/node_modules/@inquirer/type/package.json

@@ -0,0 +1,106 @@
+{
+  "name": "@inquirer/type",
+  "version": "3.0.10",
+  "description": "Inquirer core TS types",
+  "keywords": [
+    "answer",
+    "answers",
+    "ask",
+    "base",
+    "cli",
+    "command",
+    "command-line",
+    "confirm",
+    "enquirer",
+    "generate",
+    "generator",
+    "hyper",
+    "input",
+    "inquire",
+    "inquirer",
+    "interface",
+    "iterm",
+    "javascript",
+    "menu",
+    "node",
+    "nodejs",
+    "prompt",
+    "promptly",
+    "prompts",
+    "question",
+    "readline",
+    "scaffold",
+    "scaffolder",
+    "scaffolding",
+    "stdin",
+    "stdout",
+    "terminal",
+    "tty",
+    "ui",
+    "yeoman",
+    "yo",
+    "zsh",
+    "types",
+    "typescript"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/SBoudrias/Inquirer.js.git"
+  },
+  "license": "MIT",
+  "author": "Simon Boudrias <admin@simonboudrias.com>",
+  "sideEffects": false,
+  "type": "module",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "import": {
+        "types": "./dist/esm/index.d.ts",
+        "default": "./dist/esm/index.js"
+      },
+      "require": {
+        "types": "./dist/commonjs/index.d.ts",
+        "default": "./dist/commonjs/index.js"
+      }
+    }
+  },
+  "main": "./dist/commonjs/index.js",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/commonjs/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "attw": "attw --pack",
+    "tsc": "tshy"
+  },
+  "devDependencies": {
+    "@arethetypeswrong/cli": "^0.18.2",
+    "@repo/tsconfig": "0.0.0",
+    "tshy": "^3.0.3"
+  },
+  "peerDependencies": {
+    "@types/node": ">=18"
+  },
+  "peerDependenciesMeta": {
+    "@types/node": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "tshy": {
+    "exclude": [
+      "src/**/*.test.ts"
+    ],
+    "exports": {
+      "./package.json": "./package.json",
+      ".": "./src/index.ts"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "gitHead": "6881993e517e76fa891b72e1f5086fd11f7676ac"
+}

data/payload/node_modules/@oclif/core/LICENSE

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

data/payload/node_modules/@oclif/core/README.md

@@ -0,0 +1,150 @@
+<img src="https://user-images.githubusercontent.com/449385/38243295-e0a47d58-372e-11e8-9bc0-8c02a6f4d2ac.png" width="260" height="73">
+
+# oclif: Node.JS Open CLI Framework
+
+[![Version](https://img.shields.io/npm/v/@oclif/core.svg)](https://npmjs.org/package/@oclif/core)
+[![Downloads/week](https://img.shields.io/npm/dw/@oclif/core.svg)](https://npmjs.org/package/@oclif/core)
+[![License](https://img.shields.io/npm/l/@oclif/core.svg)](https://github.com/oclif/core/blob/main/LICENSE)
+
+# 🗒 Description
+
+This is a framework for building CLIs in Node.js. This framework was built out of the [Salesforce CLI](https://github.com/salesforcecli/cli) but generalized to build any custom CLI. It's designed both for single-file CLIs with a few flag options (like `cat` or `ls`), or for very complex CLIs that have subcommands (like `git` or `heroku`).
+
+[See the docs for more information](http://oclif.io/docs/introduction).
+
+# 🚀 Getting Started Tutorial
+
+The [Getting Started tutorial](http://oclif.io/docs/introduction) is a step-by-step guide to introduce you to oclif. If you have not developed anything in a command line before, this tutorial is a great place to get started.
+
+# ✨ Features
+
+- **Flag/Argument parsing** - No CLI framework would be complete without a flag parser. We've built a custom one from years of experimentation that we feel consistently handles user input flexible enough for the user to be able to use the CLI in ways they expect, but without compromising strictness guarantees to the developer.
+- **Super Speed** - The overhead for running an oclif CLI command is almost nothing. [It requires very few dependencies](https://www.npmjs.com/package/@oclif/core?activeTab=dependencies) (only 28 dependencies in a minimal setup—including all transitive dependencies). Also, only the command to be executed will be required with node. So large CLIs with many commands will load equally as fast as a small one with a single command.
+- **CLI Generator** - Run a single command to scaffold out a fully functional CLI and get started quickly. See [Getting Started Tutorial](<[#-usage](https://oclif.io/docs/introduction.html)>).
+- **Testing Helpers** - We've put a lot of work into making commands easier to test and mock out stdout/stderr. The generator will automatically create [scaffolded tests](https://github.com/oclif/hello-world/blob/main/test/commands/hello.test.ts).
+- **Auto-documentation** - By default you can pass `--help` to the CLI to get help such as flag options and argument information. This information is also automatically placed in the README whenever the npm package of the CLI is published. See the [hello-world CLI example](https://github.com/oclif/hello-world)
+- **Plugins** - Using [plugins](https://oclif.io/docs/plugins), users of the CLI can extend it with new functionality, a CLI can be split into modular components, and functionality can be shared amongst multiple CLIs. See [Building your own plugin](https://oclif.io/docs/plugins#building-your-own-plugin).
+- **Hooks** - Use lifecycle hooks to run functionality any time a CLI starts, or on custom triggers. Use this whenever custom functionality needs to be shared between various components of the CLI.
+- **TypeScript** - Everything in the core of oclif is written in TypeScript and the generator will build fully configured TypeScript CLIs. If you use plugins support, the CLI will automatically use `ts-node` to run the plugins enabling you to use TypeScript with minimal-to-no boilerplate needed for any oclif CLI.
+- **Auto-updating Installers** - oclif can package your CLI into [different installers](https://oclif.io/docs/releasing) that will not require the user to already have node installed on the machine. These can be made auto-updatable by using [plugin-update](https://github.com/oclif/plugin-update).
+- **Everything is Customizable** - Pretty much anything can be swapped out and replaced inside oclif if needed—including the arg/flag parser.
+- **Autocomplete** - Automatically include autocomplete for your CLI. This includes not only command names and flag names, but flag values as well. For example, it's possible to configure the Heroku CLI to have completions for Heroku app names:
+
+```
+$ heroku info --app=<tab><tab> # will complete with all the Heroku apps a user has in their account
+```
+
+# 📌 Requirements
+
+Currently, Node 18+ is supported. We support the [LTS versions](https://nodejs.org/en/about/releases) of Node. You can add the [node](https://www.npmjs.com/package/node) package to your CLI to ensure users are running a specific version of Node.
+
+# 📌 Migrating
+
+See the [v3 migration guide](./guides/V3_MIGRATION.md) for an overview of breaking changes that occurred between v2 and v3.
+
+See the [v2 migration guide](./guides/V2_MIGRATION.md) for an overview of breaking changes that occurred between v1 and v2.
+
+Migrating from `@oclif/config` and `@oclif/command`? See the [v1 migration guide](./guides/PRE_CORE_MIGRATION.md).
+
+# 📌 Documentation
+
+The official oclif website, [oclif.io](https://oclif.io/), contains all the documentation you need for developing a CLI with oclif.
+
+If there's anything you'd like to see in the documentation, please submit an issue on the [oclif.github.io repo](https://github.com/oclif/oclif.github.io).
+
+# 🚀 Standalone Usage
+
+We strongly encourage you generate an oclif CLI using the [oclif cli](https://github.com/oclif/oclif). The generator will generate an npm package with `@oclif/core` as a dependency.
+
+You can, however, use `@oclif/core` in a standalone script like this:
+
+```typescript
+#!/usr/bin/env -S node --loader ts-node/esm --no-warnings=ExperimentalWarning
+
+import * as fs from 'fs'
+import {Command, Flags, flush, handle} from '@oclif/core'
+
+class LS extends Command {
+  static description = 'List the files in a directory.'
+  static flags = {
+    version: Flags.version(),
+    help: Flags.help(),
+    dir: Flags.string({
+      char: 'd',
+      default: process.cwd(),
+    }),
+  }
+
+  async run() {
+    const {flags} = await this.parse(LS)
+    const files = fs.readdirSync(flags.dir)
+    for (const f of files) {
+      this.log(f)
+    }
+  }
+}
+
+LS.run(process.argv.slice(2), {
+  root: import.meta.dirname,
+  // Tell oclif what the contents of the package.json are.
+  // You could also set these in your package.json but specifying
+  // them here is useful if you're attempting to bundle your CLI
+  // without a package.json
+  pjson: {
+    name: 'ls',
+    version: '0.0.1',
+    oclif: {
+      // Tell oclif that this is a single command CLI
+      // See: https://oclif.io/docs/command_discovery_strategies
+      commands: {
+        strategy: 'single',
+        target: 'index.js',
+      },
+    },
+  },
+}).then(
+  async () => {
+    await flush()
+  },
+  async (err) => {
+    await handle(err)
+  },
+)
+```
+
+Then run it like this:
+
+```sh-session
+$ ts-node myscript.ts
+...files in current dir...
+```
+
+You can also use oclif's `Parser` separately:
+
+```javascript
+// index.js
+import {Args, Flags, Parser} from '@oclif/core'
+
+const {args, flags} = await Parser.parse(process.argv.slice(2), {
+  args: {
+    name: Args.string({required: true}),
+  },
+  flags: {
+    from: Flags.string({char: 'f', default: 'oclif'}),
+  },
+})
+
+console.log(`hello ${args.name} from ${flags.from}`)
+```
+
+```
+$ node index.js world --from oclif
+
+hello world from oclif
+```
+
+**NOTE** If you're using the `Parser` class, you will not be able to use the builtin `help` and `version` flags since those require the context of an oclif project.
+
+🚀 Contributing
+
+See the [contributing guide](./CONTRIBUTING.md).

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

@@ -0,0 +1,56 @@
+import { URL } from 'node:url';
+import { Arg, ArgDefinition } from './interfaces/parser';
+/**
+ * Create a custom arg.
+ *
+ * @example
+ * type Id = string
+ * type IdOpts = { startsWith: string; length: number };
+ *
+ * export const myArg = custom<Id, IdOpts>({
+ *   parse: async (input, opts) => {
+ *     if (input.startsWith(opts.startsWith) && input.length === opts.length) {
+ *       return input
+ *     }
+ *
+ *     throw new Error('Invalid id')
+ *   },
+ * })
+ */
+export declare function custom<T = string, P = Record<string, unknown>>(_defaults: Partial<Arg<T, P>>): ArgDefinition<T, P>;
+export declare const boolean: ArgDefinition<boolean, Record<string, unknown>>;
+export declare const integer: ArgDefinition<number, {
+    max?: number;
+    min?: number;
+}>;
+export declare const directory: ArgDefinition<string, {
+    exists?: boolean;
+}>;
+export declare const file: ArgDefinition<string, {
+    exists?: boolean;
+}>;
+/**
+ * Initializes a string as a URL. Throws an error
+ * if the string is not a valid URL.
+ */
+export declare const url: ArgDefinition<URL, Record<string, unknown>>;
+declare const stringArg: ArgDefinition<string, Record<string, unknown>>;
+export { stringArg as string };
+type ReadonlyElementOf<T extends ReadonlyArray<unknown>> = T[number];
+/**
+ * Create an arg that infers the type from the provided options.
+ *
+ * The provided `options` must be a readonly array in order for type inference to work.
+ *
+ * @example
+ * export default class MyCommand extends Command {
+ *   static args = {
+ *     stage: Args.option({
+ *       options: ['production', 'staging', 'development'] as const,
+ *     })(),
+ *   }
+ * }
+ */
+export declare function option<T extends readonly string[]>(defaults: Omit<Partial<Arg<ReadonlyElementOf<T>>>, 'default' | 'multiple' | 'required'> & {
+    options: T;
+}): ArgDefinition<(typeof defaults.options)[number]>;

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

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.string = exports.url = exports.file = exports.directory = exports.integer = exports.boolean = void 0;
+exports.custom = custom;
+exports.option = option;
+const node_url_1 = require("node:url");
+const fs_1 = require("./util/fs");
+const util_1 = require("./util/util");
+function custom(defaults) {
+    return (options = {}) => ({
+        parse: async (i, _context, _opts) => i,
+        ...defaults,
+        ...options,
+        input: [],
+        type: 'option',
+    });
+}
+exports.boolean = custom({
+    parse: async (b) => Boolean(b) && (0, util_1.isNotFalsy)(b),
+});
+exports.integer = custom({
+    async parse(input, _, opts) {
+        if (!/^-?\d+$/.test(input))
+            throw new Error(`Expected an integer but received: ${input}`);
+        const num = Number.parseInt(input, 10);
+        if (opts.min !== undefined && num < opts.min)
+            throw new Error(`Expected an integer greater than or equal to ${opts.min} but received: ${input}`);
+        if (opts.max !== undefined && num > opts.max)
+            throw new Error(`Expected an integer less than or equal to ${opts.max} but received: ${input}`);
+        return num;
+    },
+});
+exports.directory = custom({
+    async parse(input, _, opts) {
+        if (opts.exists)
+            return (0, fs_1.dirExists)(input);
+        return input;
+    },
+});
+exports.file = custom({
+    async parse(input, _, opts) {
+        if (opts.exists)
+            return (0, fs_1.fileExists)(input);
+        return input;
+    },
+});
+/**
+ * Initializes a string as a URL. Throws an error
+ * if the string is not a valid URL.
+ */
+exports.url = custom({
+    async parse(input) {
+        try {
+            return new node_url_1.URL(input);
+        }
+        catch {
+            throw new Error(`Expected a valid url but received: ${input}`);
+        }
+    },
+});
+const stringArg = custom({});
+exports.string = stringArg;
+/**
+ * Create an arg that infers the type from the provided options.
+ *
+ * The provided `options` must be a readonly array in order for type inference to work.
+ *
+ * @example
+ * export default class MyCommand extends Command {
+ *   static args = {
+ *     stage: Args.option({
+ *       options: ['production', 'staging', 'development'] as const,
+ *     })(),
+ *   }
+ * }
+ */
+function option(defaults) {
+    return (options = {}) => ({
+        parse: async (i, _context, _opts) => i,
+        ...defaults,
+        ...options,
+        input: [],
+        type: 'option',
+    });
+}

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

@@ -0,0 +1,27 @@
+import { Config } from './config/config';
+import { OclifConfiguration, Plugin } from './interfaces';
+type CacheContents = {
+    rootPlugin: Plugin;
+    config: Config;
+    exitCodes: OclifConfiguration['exitCodes'];
+    '@oclif/core': OclifCoreInfo;
+};
+type OclifCoreInfo = {
+    name: string;
+    version: string;
+};
+type ValueOf<T> = T[keyof T];
+/**
+ * A simple cache for storing values that need to be accessed globally.
+ */
+export default class Cache extends Map<keyof CacheContents, ValueOf<CacheContents>> {
+    static instance: Cache;
+    constructor();
+    static getInstance(): Cache;
+    get(_key: 'config'): Config | undefined;
+    get(_key: '@oclif/core'): OclifCoreInfo;
+    get(_key: 'rootPlugin'): Plugin | undefined;
+    get(_key: 'exitCodes'): OclifConfiguration['exitCodes'] | undefined;
+    private getOclifCoreMeta;
+}
+export {};

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

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+/**
+ * A simple cache for storing values that need to be accessed globally.
+ */
+class Cache extends Map {
+    static instance;
+    constructor() {
+        super();
+        this.set('@oclif/core', this.getOclifCoreMeta());
+    }
+    static getInstance() {
+        if (!Cache.instance) {
+            Cache.instance = new Cache();
+        }
+        return Cache.instance;
+    }
+    get(key) {
+        return super.get(key);
+    }
+    getOclifCoreMeta() {
+        try {
+            return { name: '@oclif/core', version: require('@oclif/core/package.json').version };
+        }
+        catch {
+            try {
+                return {
+                    name: '@oclif/core',
+                    version: JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.join)(__dirname, '..', 'package.json'), 'utf8')).version,
+                };
+            }
+            catch {
+                return { name: '@oclif/core', version: 'unknown' };
+            }
+        }
+    }
+}
+exports.default = Cache;