oclif 4.5.7 → 4.6.1-dev.0

package/README.md

@@ -1,54 +1,38 @@
 <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
+# `oclif` CLI
 
 [![Version](https://img.shields.io/npm/v/oclif.svg)](https://npmjs.org/package/oclif)
-[![Downloads/week](https://img.shields.io/npm/dw/@oclif/command.svg)](https://npmjs.org/package/@oclif/core)
+[![Downloads/week](https://img.shields.io/npm/dw/oclif.svg)](https://npmjs.org/package/oclif/oclif)
 [![License](https://img.shields.io/npm/l/oclif.svg)](https://github.com/oclif/oclif/blob/main/package.json)
 
 <!-- toc -->
-* [oclif: Node.JS Open CLI Framework](#oclif-nodejs-open-cli-framework)
-* [🗒 Description](#-description)
-* [🚀 Getting Started Tutorial](#-getting-started-tutorial)
-* [✨ Features](#-features)
-* [📌 Requirements](#-requirements)
-* [📌 Migrating from V1](#-migrating-from-v1)
-* [🏗 Usage](#-usage)
-* [📚 Examples](#-examples)
-* [🔨 Commands](#-commands)
-* [Command Topics](#command-topics)
-* [🏭 Related Repositories](#-related-repositories)
-* [🦔 Learn More](#-learn-more)
-* [📣 Feedback](#-feedback)
+
+- [`oclif` CLI](#oclif-cli)
+- [🗒 Description](#-description)
+- [🚀 Getting Started Tutorial](#-getting-started-tutorial)
+- [📌 Requirements](#-requirements)
+- [📌 Migrating from V1](#-migrating-from-v1)
+- [🏗 Usage](#-usage)
+- [📚 Examples](#-examples)
+- [🔨 Commands](#-commands)
+- [Command Topics](#command-topics)
+- [🚀 Contributing](#-contributing)
+- [🏭 Related Repositories](#-related-repositories)
+- [🦔 Learn More](#-learn-more)
 <!-- tocstop -->
 
 # 🗒 Description
 
-This is a framework for building CLIs in Node.js. This framework was built out of the [Heroku CLI](https://cli.heroku.com) but generalized to build any custom CLI. It's designed both for single-file CLIs with a few flag options, or for very complex CLIs that have subcommands (like git or heroku).
+This is the `oclif` CLI for the [Open CLI Framework](https://github.com/oclif/core), that supports the development of oclif plugins and CLIs.
 
-[See the docs for more information](http://oclif.io/docs/introduction).
+[See the docs for more information](http://oclif.io).
 
 # 🚀 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/command?activeTab=dependencies) (only 35 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 [Usage](#-usage) below.
-- **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 [multi-command CLI example](https://github.com/oclif/example-multi-ts)
-- **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
-```
+See [Usage](#-usage) below for an overview of the `oclif` CLI.
 
 # 📌 Requirements
 
@@ -111,29 +95,29 @@ hello world! (./src/commands/hello/world.ts)
 # 🔨 Commands
 
 <!-- commands -->
+
 # Command Topics
 
-* [`oclif generate`](docs/generate.md) - generate a new CLI
-* [`oclif help`](docs/help.md) - Display help for oclif.
-* [`oclif manifest`](docs/manifest.md) - generates plugin manifest json
-* [`oclif pack`](docs/pack.md) - package an oclif CLI into installable artifacts
-* [`oclif promote`](docs/promote.md) - promote CLI builds to a S3 release channel
-* [`oclif readme`](docs/readme.md) - adds commands to README.md in current directory
-* [`oclif upload`](docs/upload.md) - upload installable CLI artifacts to AWS S3
+- [`oclif generate`](docs/generate.md) - Generate a new CLI
+- [`oclif help`](docs/help.md) - Display help for oclif.
+- [`oclif manifest`](docs/manifest.md) - Generates plugin manifest json (oclif.manifest.json).
+- [`oclif pack`](docs/pack.md) - package an oclif CLI into installable artifacts
+- [`oclif promote`](docs/promote.md) - Promote CLI builds to a S3 release channel.
+- [`oclif readme`](docs/readme.md) - Adds commands to README.md in current directory.
+- [`oclif upload`](docs/upload.md) - upload installable CLI artifacts to AWS S3
 
 <!-- commandsstop -->
 
+# 🚀 Contributing
+
+See the [contributing guide](./CONRTIBUTING.md).
+
 # 🏭 Related Repositories
 
 - [@oclif/core](https://github.com/oclif/core) - Base library for oclif. This can be used directly without the generator.
-- [@oclif/cli-ux](https://github.com/oclif/cli-ux) - Library for common CLI UI utilities.
 - [@oclif/test](https://github.com/oclif/test) - Test helper for oclif.
 
 # 🦔 Learn More
 
 - [Salesforce Release Announcement](https://engineering.salesforce.com/open-sourcing-oclif-the-cli-framework-that-powers-our-clis-21fbda99d33a)
 - [Heroku Release Announcement](https://blog.heroku.com/open-cli-framework)
-
-# 📣 Feedback
-
-If you have any suggestions or want to let us know what you think of oclif, send us a message at <alm-cli@salesforce.com>

package/lib/commands/generate/command.d.ts

@@ -1,10 +1,11 @@
-import CommandBase from './../../command-base';
-export default class GenerateCommand extends CommandBase {
+import { GeneratorCommand } from '../../generator';
+export default class GenerateCommand extends GeneratorCommand<typeof GenerateCommand> {
     static args: {
         name: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
     };
     static description: string;
     static flags: {
+        'commands-dir': import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
         force: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;

package/lib/commands/generate/command.js

@@ -4,21 +4,44 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const core_1 = require("@oclif/core");
-const command_base_1 = __importDefault(require("./../../command-base"));
-class GenerateCommand extends command_base_1.default {
+const chalk_1 = __importDefault(require("chalk"));
+const change_case_1 = require("change-case");
+const node_path_1 = require("node:path");
+const generator_1 = require("../../generator");
+class GenerateCommand extends generator_1.GeneratorCommand {
     static args = {
         name: core_1.Args.string({ description: 'name of command', required: true }),
     };
-    static description = 'add a command to an existing CLI or plugin';
+    static description = 'Add a command to an existing CLI or plugin.';
     static flags = {
-        force: core_1.Flags.boolean({ description: 'overwrite existing files' }),
+        'commands-dir': core_1.Flags.string({ default: 'src/commands', description: 'The directory to create the command in.' }),
+        force: core_1.Flags.boolean({ description: 'Overwrite existing files.' }),
     };
     async run() {
-        const { args, flags } = await this.parse(GenerateCommand);
-        await super.generate('command', {
-            force: flags.force,
-            name: args.name,
-        });
+        const packageJSON = await (0, generator_1.readPJSON)(process.cwd());
+        if (!packageJSON)
+            throw new core_1.Errors.CLIError('not in a project directory');
+        const topicSeparator = packageJSON.oclif?.topicSeparator ?? ':';
+        this.log(`Adding ${chalk_1.default.dim(this.args.name.replaceAll(':', topicSeparator))} to ${packageJSON.name}!`);
+        const cmdPath = this.args.name.split(':').join('/');
+        const destination = (0, node_path_1.join)(process.cwd(), this.flags['commands-dir'], `${cmdPath}.ts`);
+        let bin = packageJSON.oclif?.bin ?? packageJSON.oclif?.dirname ?? packageJSON.name;
+        if (bin.includes('/'))
+            bin = bin.split('/').at(-1);
+        const opts = {
+            bin,
+            className: (0, change_case_1.pascalCase)(this.args.name),
+            cmd: `${bin} ${this.args.name}`,
+            name: this.args.name,
+            path: destination,
+            type: 'command',
+        };
+        await this.template((0, node_path_1.join)(this.templatesDir, 'src', 'command.ts.ejs'), destination, opts);
+        if (packageJSON.devDependencies?.mocha) {
+            const testTemplatePath = (0, node_path_1.join)(this.templatesDir, 'test', 'command.test.ts.ejs');
+            const testDestination = (0, node_path_1.join)(process.cwd(), 'test', 'commands', `${cmdPath}.test.ts`);
+            await this.template(testTemplatePath, testDestination, opts);
+        }
     }
 }
 exports.default = GenerateCommand;

package/lib/commands/generate/hook.d.ts

@@ -1,5 +1,5 @@
-import CommandBase from './../../command-base';
-export default class GenerateHook extends CommandBase {
+import { GeneratorCommand } from '../../generator';
+export default class GenerateHook extends GeneratorCommand<typeof GenerateHook> {
     static args: {
         name: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
     };

package/lib/commands/generate/hook.js

@@ -27,28 +27,57 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const core_1 = require("@oclif/core");
+const chalk_1 = __importDefault(require("chalk"));
 const fs = __importStar(require("fs-extra"));
+const promises_1 = require("node:fs/promises");
 const node_path_1 = require("node:path");
-const command_base_1 = __importDefault(require("./../../command-base"));
-class GenerateHook extends command_base_1.default {
+const generator_1 = require("../../generator");
+const util_1 = require("../../util");
+class GenerateHook extends generator_1.GeneratorCommand {
     static args = {
-        name: core_1.Args.string({ description: 'name of hook (snake_case)', required: true }),
+        name: core_1.Args.string({ description: 'Name of hook (snake_case).', required: true }),
     };
-    static description = 'add a hook to an existing CLI or plugin';
+    static description = 'Add a hook to an existing CLI or plugin.';
     static flags = {
-        event: core_1.Flags.string({ default: 'init', description: 'event to run hook on' }),
-        force: core_1.Flags.boolean({ description: 'overwrite existing files' }),
+        event: core_1.Flags.string({
+            default: 'init',
+            description: 'Event to run hook on.',
+        }),
+        force: core_1.Flags.boolean({
+            description: 'Overwrite existing files.',
+        }),
     };
     async run() {
-        const { args, flags } = await this.parse(GenerateHook);
+        const packageJSON = await (0, generator_1.readPJSON)(process.cwd());
+        if (!packageJSON)
+            throw new core_1.Errors.CLIError('not in a project directory');
+        this.log(`Adding a ${chalk_1.default.dim(this.flags.event)} hook to ${packageJSON.name}!`);
+        const source = (0, node_path_1.join)(this.templatesDir, 'src', 'hook.ts.ejs');
+        const dest = (0, node_path_1.join)(process.cwd(), 'src', 'hooks', this.flags.event, `${this.args.name}.ts`);
+        await this.template(source, dest, { event: this.flags.event });
+        if (packageJSON.devDependencies?.mocha) {
+            const testSource = (0, node_path_1.join)(this.templatesDir, 'test', 'hook.test.ts.ejs');
+            const testDest = (0, node_path_1.join)(process.cwd(), 'test', 'hooks', this.flags.event, `${this.args.name}.test.ts`);
+            await this.template(testSource, testDest);
+        }
         const tsConfigPath = (0, node_path_1.resolve)(process.cwd(), 'tsconfig.json');
         const tsConfig = await fs.readJSON(tsConfigPath).catch(() => ({}));
-        await super.generate('hook', {
-            event: flags.event,
-            force: flags.force,
-            name: args.name,
-            outDir: tsConfig.compilerOptions?.outDir ?? 'dist',
-        });
+        const outDir = tsConfig.compilerOptions?.outDir ?? 'dist';
+        const hooks = packageJSON.oclif?.hooks ?? {};
+        hooks[this.flags.event] = hooks[this.flags.event]
+            ? (0, util_1.uniq)([
+                ...(0, util_1.castArray)(hooks[this.flags.event]),
+                `./${outDir}/hooks/${this.flags.event}/${this.args.name}`,
+            ]).sort()
+            : `./${outDir}/hooks/${this.flags.event}/${this.args.name}`;
+        const updatedPackageJSON = {
+            ...packageJSON,
+            oclif: {
+                ...packageJSON.oclif,
+                hooks,
+            },
+        };
+        await (0, promises_1.writeFile)((0, node_path_1.resolve)(process.cwd(), 'package.json'), JSON.stringify(updatedPackageJSON, null, 2));
     }
 }
 exports.default = GenerateHook;

package/lib/commands/generate.d.ts

@@ -1,11 +1,65 @@
-import CommandBase from './../command-base';
-export default class Generate extends CommandBase {
+import { GeneratorCommand } from '../generator';
+export default class Generate extends GeneratorCommand<typeof Generate> {
     static args: {
         name: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
     };
     static description: string;
+    static examples: {
+        command: string;
+        description: string;
+    }[];
+    static flaggablePrompts: {
+        author: {
+            message: string;
+            validate: (d: string) => true | "Author cannot be empty";
+        };
+        bin: {
+            message: string;
+            validate: (d: string) => true | "Invalid bin name";
+        };
+        description: {
+            message: string;
+            validate: (d: string) => true | "Description cannot be empty";
+        };
+        license: {
+            message: string;
+            validate: (d: string) => true | "License cannot be empty";
+        };
+        'module-type': {
+            message: string;
+            options: string[];
+            validate: (d: string) => true | "Invalid module type";
+        };
+        name: {
+            message: string;
+            validate: (d: string) => true | "Invalid package name";
+        };
+        owner: {
+            message: string;
+            validate: (d: string) => true | "Owner cannot be empty";
+        };
+        'package-manager': {
+            message: string;
+            options: string[];
+            validate: (d: string) => true | "Invalid package manager";
+        };
+        repository: {
+            message: string;
+            validate: (d: string) => true | "Repo cannot be empty";
+        };
+    };
     static flags: {
-        defaults: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'output-dir': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        name: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        description: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        bin: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        author: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        license: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        "module-type": import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        owner: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        "package-manager": import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        repository: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
     };
+    static summary: string;
     run(): Promise<void>;
 }

package/lib/commands/generate.js

@@ -3,24 +3,237 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable unicorn/no-await-expression-member */
 const core_1 = require("@oclif/core");
-const command_base_1 = __importDefault(require("./../command-base"));
-class Generate extends command_base_1.default {
+const chalk_1 = __importDefault(require("chalk"));
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const validate_npm_package_name_1 = __importDefault(require("validate-npm-package-name"));
+const generator_1 = require("../generator");
+const util_1 = require("../util");
+async function fetchGithubUserFromAPI() {
+    const token = process.env.GITHUB_TOKEN ?? process.env.GH_TOKEN;
+    if (!token)
+        return;
+    const { default: got } = await import('got');
+    const headers = {
+        Accept: 'application/vnd.github.v3+json',
+        Authorization: `Bearer ${token}`,
+    };
+    try {
+        const { login, name } = await got('https://api.github.com/user', { headers }).json();
+        return { login, name };
+    }
+    catch { }
+}
+async function fetchGithubUserFromGit() {
+    try {
+        const result = await (0, generator_1.exec)('git config --get user.name');
+        return result.stdout.trim();
+    }
+    catch { }
+}
+async function fetchGithubUser() {
+    return (await fetchGithubUserFromAPI()) ?? { name: await fetchGithubUserFromGit() };
+}
+function determineDefaultAuthor(user, defaultValue) {
+    const { login, name } = user ?? { login: undefined, name: undefined };
+    if (name && login)
+        return `${name} @${login}`;
+    if (name)
+        return name;
+    if (login)
+        return `@${login}`;
+    return defaultValue;
+}
+async function clone(repo, location) {
+    try {
+        await (0, generator_1.exec)(`git clone https://github.com/oclif/${repo}.git "${location}" --depth=1`);
+    }
+    catch (error) {
+        const err = error instanceof Error
+            ? new core_1.Errors.CLIError(error)
+            : new core_1.Errors.CLIError('An error occurred while cloning the template repo');
+        throw err;
+    }
+}
+const FLAGGABLE_PROMPTS = {
+    author: {
+        message: 'Author',
+        validate: (d) => d.length > 0 || 'Author cannot be empty',
+    },
+    bin: {
+        message: 'Command bin name the CLI will export',
+        validate: (d) => (0, util_1.validateBin)(d) || 'Invalid bin name',
+    },
+    description: {
+        message: 'Description',
+        validate: (d) => d.length > 0 || 'Description cannot be empty',
+    },
+    license: {
+        message: 'License',
+        validate: (d) => d.length > 0 || 'License cannot be empty',
+    },
+    'module-type': {
+        message: 'Select a module type',
+        options: ['CommonJS', 'ESM'],
+        validate: (d) => ['CommonJS', 'ESM'].includes(d) || 'Invalid module type',
+    },
+    name: {
+        message: 'NPM package name',
+        validate: (d) => (0, validate_npm_package_name_1.default)(d).validForNewPackages || 'Invalid package name',
+    },
+    owner: {
+        message: 'Who is the GitHub owner of repository (https://github.com/OWNER/repo)',
+        validate: (d) => d.length > 0 || 'Owner cannot be empty',
+    },
+    'package-manager': {
+        message: 'Select a package manager',
+        options: ['npm', 'yarn'],
+        validate: (d) => ['npm', 'yarn'].includes(d) || 'Invalid package manager',
+    },
+    repository: {
+        message: 'What is the GitHub name of repository (https://github.com/owner/REPO)',
+        validate: (d) => d.length > 0 || 'Repo cannot be empty',
+    },
+};
+class Generate extends generator_1.GeneratorCommand {
     static args = {
-        name: core_1.Args.string({ description: 'directory name of new project', required: true }),
+        name: core_1.Args.string({ description: 'Directory name of new project.', required: true }),
     };
-    static description = `generate a new CLI
-This will clone the template repo 'oclif/hello-world' and update package properties`;
+    static description = `This will clone the template repo and update package properties. For CommonJS, the 'oclif/hello-world' template will be used and for ESM, the 'oclif/hello-world-esm' template will be used.`;
+    static examples = [
+        {
+            command: '<%= config.bin %> <%= command.id %> my-cli',
+            description: 'Generate a new CLI with prompts for all properties',
+        },
+        {
+            command: '<%= config.bin %> <%= command.id %> my-cli --yes',
+            description: 'Automatically accept default values for all prompts',
+        },
+        {
+            command: '<%= config.bin %> <%= command.id %> my-cli --module-type CommonJS --author "John Doe"',
+            description: 'Supply answers for specific prompts',
+        },
+        {
+            command: '<%= config.bin %> <%= command.id %> my-cli --module-type CommonJS --author "John Doe" --yes',
+            description: 'Supply answers for specific prompts and accept default values for the rest',
+        },
+    ];
+    static flaggablePrompts = FLAGGABLE_PROMPTS;
     static flags = {
-        defaults: core_1.Flags.boolean({ hidden: true }),
+        ...(0, generator_1.makeFlags)(FLAGGABLE_PROMPTS),
+        'output-dir': core_1.Flags.directory({
+            char: 'd',
+            description: 'Directory to build the CLI in.',
+        }),
     };
+    static summary = 'Generate a new CLI';
     async run() {
-        const { args, flags } = await this.parse(Generate);
-        await super.generate('cli', {
-            defaults: flags.defaults,
-            force: true,
-            name: args.name,
+        const location = this.flags['output-dir'] ? (0, node_path_1.join)(this.flags['output-dir'], this.args.name) : (0, node_path_1.resolve)(this.args.name);
+        this.log(`Generating ${this.args.name} in ${chalk_1.default.green(location)}`);
+        const moduleType = await this.getFlagOrPrompt({
+            defaultValue: 'ESM',
+            name: 'module-type',
+            type: 'select',
+        });
+        const template = moduleType === 'ESM' ? 'hello-world-esm' : 'hello-world';
+        await clone(template, location);
+        await (0, promises_1.rm)((0, node_path_1.join)(location, '.git'), { force: true, recursive: true });
+        // We just cloned the template repo so we're sure it has a package.json
+        const packageJSON = (await (0, generator_1.readPJSON)(location));
+        const githubUser = await fetchGithubUser();
+        const name = await this.getFlagOrPrompt({ defaultValue: this.args.name, name: 'name', type: 'input' });
+        const bin = await this.getFlagOrPrompt({ defaultValue: name, name: 'bin', type: 'input' });
+        const description = await this.getFlagOrPrompt({
+            defaultValue: packageJSON.description,
+            name: 'description',
+            type: 'input',
+        });
+        const author = await this.getFlagOrPrompt({
+            defaultValue: determineDefaultAuthor(githubUser, packageJSON.author),
+            name: 'author',
+            type: 'input',
+        });
+        const license = await this.getFlagOrPrompt({
+            defaultValue: packageJSON.license,
+            name: 'license',
+            type: 'input',
+        });
+        const owner = await this.getFlagOrPrompt({
+            defaultValue: githubUser?.login ?? location.split(node_path_1.sep).at(-2) ?? packageJSON.author,
+            name: 'owner',
+            type: 'input',
+        });
+        const repository = await this.getFlagOrPrompt({
+            defaultValue: (name ?? packageJSON.repository ?? packageJSON.name).split('/').at(-1) ?? name,
+            name: 'repository',
+            type: 'input',
+        });
+        const packageManager = await this.getFlagOrPrompt({
+            defaultValue: 'npm',
+            name: 'package-manager',
+            type: 'select',
+        });
+        const updatedPackageJSON = {
+            ...packageJSON,
+            author,
+            bin: { [bin]: './bin/run.js' },
+            bugs: `https://github.com/${owner}/${repository}/issues`,
+            description,
+            homepage: `https://github.com/${owner}/${repository}`,
+            license,
+            name,
+            oclif: {
+                ...packageJSON.oclif,
+                bin,
+                dirname: bin,
+            },
+            repository: `${owner}/${repository}`,
+        };
+        if (packageManager === 'npm') {
+            const scripts = (updatedPackageJSON.scripts || {});
+            updatedPackageJSON.scripts = Object.fromEntries(Object.entries(scripts).map(([k, v]) => [k, v.replace('yarn', 'npm run')]));
+        }
+        const { default: sortPackageJson } = await import('sort-package-json');
+        await (0, promises_1.writeFile)((0, node_path_1.join)(location, 'package.json'), JSON.stringify(sortPackageJson(updatedPackageJSON), null, 2));
+        await (0, promises_1.rm)((0, node_path_1.join)(location, 'LICENSE'));
+        const existing = (await (0, promises_1.readFile)((0, node_path_1.join)(location, '.gitignore'), 'utf8')).split('\n');
+        const updated = (0, util_1.uniq)((0, util_1.compact)([
+            '*-debug.log',
+            '*-error.log',
+            'node_modules',
+            '/tmp',
+            '/dist',
+            '/lib',
+            ...(packageManager === 'yarn'
+                ? [
+                    '/package-lock.json',
+                    '.pnp.*',
+                    '.yarn/*',
+                    '!.yarn/patches',
+                    '!.yarn/plugins',
+                    '!.yarn/releases',
+                    '!.yarn/sdks',
+                    '!.yarn/versions',
+                ]
+                : ['/yarn.lock']),
+            ...existing,
+        ]))
+            .sort()
+            .join('\n') + '\n';
+        await (0, promises_1.writeFile)((0, node_path_1.join)(location, '.gitignore'), updated);
+        await (0, generator_1.exec)(`${packageManager} install`, { cwd: location, silent: false });
+        await (0, generator_1.exec)(`${(0, node_path_1.join)(location, 'node_modules', '.bin', 'oclif')} readme`, {
+            cwd: location,
+            // When testing this command in development, you get noisy compilation errors as a result of running
+            // this in a spawned process. Setting the NODE_ENV to production will silence these warnings. This
+            // doesn't affect the behavior of the command in production since the NODE_ENV is already set to production
+            // in that scenario.
+            env: { ...process.env, NODE_ENV: 'production' },
+            silent: false,
         });
+        this.log(`\nCreated ${chalk_1.default.green(name)}`);
     }
 }
 exports.default = Generate;

package/lib/commands/manifest.js

@@ -22,13 +22,9 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 const core_1 = require("@oclif/core");
 const fs_extra_1 = require("fs-extra");
-const got_1 = __importDefault(require("got"));
 const node_child_process_1 = require("node:child_process");
 const os = __importStar(require("node:os"));
 const path = __importStar(require("node:path"));
@@ -47,14 +43,14 @@ async function fileExists(filePath) {
 }
 class Manifest extends core_1.Command {
     static args = {
-        path: core_1.Args.string({ default: '.', description: 'path to plugin' }),
+        path: core_1.Args.string({ default: '.', description: 'Path to plugin.' }),
     };
-    static description = 'generates plugin manifest json';
+    static description = 'Generates plugin manifest json (oclif.manifest.json).';
     static flags = {
         jit: core_1.Flags.boolean({
             allowNo: true,
             default: true,
-            summary: 'append commands from JIT plugins in manifest',
+            summary: 'Append commands from JIT plugins in manifest.',
         }),
     };
     async run() {
@@ -70,6 +66,7 @@ class Manifest extends core_1.Command {
         if (flags.jit && packageJson.oclif?.jitPlugins) {
             this.debug('jitPlugins: %s', packageJson.oclif.jitPlugins);
             const tmpDir = os.tmpdir();
+            const { default: got } = await import('got');
             const promises = Object.entries(packageJson.oclif.jitPlugins).map(async ([jitPlugin, version]) => {
                 const pluginDir = jitPlugin.replace('/', '-').replace('@', '');
                 const fullPath = path.join(tmpDir, pluginDir);
@@ -79,7 +76,7 @@ class Manifest extends core_1.Command {
                 const resolvedVersion = await this.getVersion(jitPlugin, version);
                 const tarballUrl = await this.getTarballUrl(jitPlugin, resolvedVersion);
                 const tarball = path.join(fullPath, path.basename(tarballUrl));
-                await pipeline(got_1.default.stream(tarballUrl), (0, fs_extra_1.createWriteStream)(tarball));
+                await pipeline(got.stream(tarballUrl), (0, fs_extra_1.createWriteStream)(tarball));
                 await this.executeCommand(`tar -xzf "${tarball}"`, { cwd: fullPath });
                 const manifest = (await (0, fs_extra_1.readJSON)(path.join(fullPath, 'package', 'oclif.manifest.json')));
                 for (const command of Object.values(manifest.commands)) {