@depup/oclif 4.22.92-depup.1

package/lib/commands/generate.js

@@ -0,0 +1,269 @@
+"use strict";
+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 errors_1 = require("@oclif/core/errors");
+const ansis_1 = require("ansis");
+const node_fs_1 = require("node:fs");
+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 log_1 = require("../log");
+const util_1 = require("../util");
+const debug = log_1.debug.new('generate');
+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;
+}
+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', 'pnpm'],
+        validate: (d) => ['npm', 'pnpm', '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 }),
+    };
+    static description = `This will generate a fully functional oclif CLI that you can build on. It will prompt you for all the necessary information to get started. If you want to skip the prompts, you can pass the --yes flag to accept the defaults for all prompts. You can also pass individual flags to set specific values for prompts.
+
+Head to oclif.io/docs/introduction to learn more about building CLIs with oclif.`;
+    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 = {
+        ...(0, generator_1.makeFlags)(FLAGGABLE_PROMPTS),
+        'dry-run': core_1.Flags.boolean({
+            char: 'n',
+            description: 'Print the files that would be created without actually creating them.',
+        }),
+        'output-dir': core_1.Flags.directory({
+            char: 'd',
+            description: 'Directory to build the CLI in.',
+        }),
+        yes: core_1.Flags.boolean({
+            aliases: ['defaults'],
+            char: 'y',
+            description: 'Use defaults for all prompts. Individual flags will override defaults.',
+        }),
+    };
+    static summary = 'Generate a new CLI';
+    async run() {
+        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 ${(0, ansis_1.green)(location)}`);
+        if ((0, node_fs_1.existsSync)(location)) {
+            throw new core_1.Errors.CLIError(`The directory ${location} already exists.`);
+        }
+        const moduleType = await this.getFlagOrPrompt({
+            defaultValue: 'ESM',
+            name: 'module-type',
+            type: 'select',
+        });
+        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: 'A new CLI generated with oclif',
+            name: 'description',
+            type: 'input',
+        });
+        const author = await this.getFlagOrPrompt({
+            defaultValue: determineDefaultAuthor(githubUser, 'Your Name Here'),
+            name: 'author',
+            type: 'input',
+        });
+        const license = await this.getFlagOrPrompt({
+            defaultValue: 'MIT',
+            name: 'license',
+            type: 'input',
+        });
+        const owner = await this.getFlagOrPrompt({
+            defaultValue: githubUser?.login ?? location.split(node_path_1.sep).at(-2) ?? 'Your Name Here',
+            name: 'owner',
+            type: 'input',
+        });
+        const repository = await this.getFlagOrPrompt({
+            defaultValue: name.split('/').at(-1) ?? name,
+            name: 'repository',
+            type: 'input',
+        });
+        const packageManager = await this.getFlagOrPrompt({
+            defaultValue: 'npm',
+            name: 'package-manager',
+            type: 'select',
+        });
+        const [sharedFiles, moduleSpecificFiles] = await Promise.all(['shared', moduleType.toLowerCase()].map((f) => (0, node_path_1.join)(this.templatesDir, 'cli', f)).map(findEjsFiles(location)));
+        debug('shared files %O', sharedFiles);
+        debug(`${moduleType} files %O`, moduleSpecificFiles);
+        await Promise.all([...sharedFiles, ...moduleSpecificFiles].map(async (file) => {
+            switch (file.name) {
+                case '.gitignore.ejs': {
+                    await this.template(file.src, file.destination, { packageManager });
+                    break;
+                }
+                case 'onPushToMain.yml.ejs':
+                case 'onRelease.yml.ejs':
+                case 'test.yml.ejs': {
+                    await this.template(file.src, file.destination, {
+                        exec: packageManager === 'yarn' ? packageManager : `${packageManager} exec`,
+                        install: packageManager === 'yarn' ? packageManager : `${packageManager} install`,
+                        packageManager,
+                        run: packageManager === 'yarn' ? packageManager : `${packageManager} run`,
+                    });
+                    break;
+                }
+                case 'package.json.ejs': {
+                    const data = {
+                        author,
+                        bin,
+                        description,
+                        license,
+                        moduleType,
+                        name,
+                        owner,
+                        pkgManagerScript: packageManager === 'yarn' ? 'yarn' : `${packageManager} run`,
+                        repository,
+                    };
+                    await this.template(file.src, file.destination, data);
+                    break;
+                }
+                case 'README.md.ejs': {
+                    await this.template(file.src, file.destination, { description, name, repository });
+                    break;
+                }
+                default: {
+                    await this.template(file.src, file.destination);
+                }
+            }
+        }));
+        if (this.flags['dry-run']) {
+            this.log(`\n[DRY RUN] Created ${(0, ansis_1.green)(name)}`);
+        }
+        else {
+            if (process.platform !== 'win32') {
+                await Promise.all([
+                    (0, generator_1.exec)(`chmod +x ${(0, node_path_1.join)(location, 'bin', 'run.js')}`),
+                    (0, generator_1.exec)(`chmod +x ${(0, node_path_1.join)(location, 'bin', 'dev.js')}`),
+                ]);
+            }
+            await (0, generator_1.exec)(`${packageManager} install`, { cwd: location, silent: false });
+            await (0, generator_1.exec)(`${packageManager} run build`, { 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 ${(0, ansis_1.green)(name)}`);
+        }
+    }
+}
+exports.default = Generate;
+const findEjsFiles = (location) => async (dir) => (await (0, promises_1.readdir)(dir, { recursive: true, withFileTypes: true }))
+    .filter((f) => f.isFile() && f.name.endsWith('.ejs'))
+    .map((f) => {
+    debug({
+        location,
+        name: f.name,
+        parentPath: f.parentPath,
+        path: f.path,
+    });
+    const path = f.path ?? f.parentPath;
+    if (!path) {
+        (0, errors_1.warn)(`Could not determine path for file ${f.name}. Skipping.`);
+        return null;
+    }
+    return {
+        destination: (0, node_path_1.join)(path.replace(dir, location), f.name.replace('.ejs', '')),
+        name: f.name,
+        src: (0, node_path_1.join)(path, f.name),
+    };
+})
+    .filter((f) => f !== null);

package/lib/commands/init.d.ts

@@ -0,0 +1,39 @@
+import { GeneratorCommand } from '../generator';
+export default class Generate extends GeneratorCommand<typeof Generate> {
+    static description: string;
+    static examples: {
+        command: string;
+        description: string;
+    }[];
+    static flaggablePrompts: {
+        bin: {
+            message: string;
+            validate: (d: string) => true | "Invalid bin name";
+        };
+        'module-type': {
+            message: string;
+            options: readonly ["ESM", "CommonJS"];
+            validate: (d: string) => true | "Invalid module type";
+        };
+        'package-manager': {
+            message: string;
+            options: readonly ["npm", "yarn", "pnpm"];
+            validate: (d: string) => true | "Invalid package manager";
+        };
+        'topic-separator': {
+            message: string;
+            options: string[];
+            validate: (d: string) => true | "Invalid topic separator";
+        };
+    };
+    static flags: {
+        'output-dir': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        bin: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        "module-type": import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        "package-manager": import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        "topic-separator": import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    static summary: string;
+    run(): Promise<void>;
+}

package/lib/commands/init.js

@@ -0,0 +1,165 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const ansis_1 = require("ansis");
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const generator_1 = require("../generator");
+const util_1 = require("../util");
+const VALID_MODULE_TYPES = ['ESM', 'CommonJS'];
+const VALID_PACKAGE_MANAGERS = ['npm', 'yarn', 'pnpm'];
+function isPackageManager(d) {
+    return VALID_PACKAGE_MANAGERS.includes(d);
+}
+function isModuleType(d) {
+    return VALID_MODULE_TYPES.includes(d);
+}
+const FLAGGABLE_PROMPTS = {
+    bin: {
+        message: 'Command bin name the CLI will export',
+        validate: (d) => (0, util_1.validateBin)(d) || 'Invalid bin name',
+    },
+    'module-type': {
+        message: 'Select a module type',
+        options: VALID_MODULE_TYPES,
+        validate: (d) => isModuleType(d) || 'Invalid module type',
+    },
+    'package-manager': {
+        message: 'Select a package manager',
+        options: VALID_PACKAGE_MANAGERS,
+        validate: (d) => isPackageManager(d) || 'Invalid package manager',
+    },
+    'topic-separator': {
+        message: 'Select a topic separator',
+        options: ['colons', 'spaces'],
+        validate: (d) => d === 'colons' || d === 'spaces' || 'Invalid topic separator',
+    },
+};
+class Generate extends generator_1.GeneratorCommand {
+    static description = 'This will add the necessary oclif bin files, add oclif config to package.json, and install @oclif/core and ts-node.';
+    static examples = [
+        {
+            command: '<%= config.bin %> <%= command.id %>',
+            description: 'Initialize a new CLI in the current directory',
+        },
+        {
+            command: '<%= config.bin %> <%= command.id %> --output-dir "/path/to/existing/project"',
+            description: 'Initialize a new CLI in a different directory',
+        },
+        {
+            command: '<%= config.bin %> <%= command.id %> --topic-separator colons --bin mycli',
+            description: 'Supply answers for specific prompts',
+        },
+    ];
+    static flaggablePrompts = FLAGGABLE_PROMPTS;
+    static flags = {
+        ...(0, generator_1.makeFlags)(FLAGGABLE_PROMPTS),
+        'output-dir': core_1.Flags.directory({
+            char: 'd',
+            description: 'Directory to initialize the CLI in.',
+            exists: true,
+        }),
+        yes: core_1.Flags.boolean({
+            aliases: ['defaults'],
+            char: 'y',
+            description: 'Use defaults for all prompts. Individual flags will override defaults.',
+        }),
+    };
+    static summary = 'Initialize a new oclif CLI';
+    async run() {
+        const outputDir = this.flags['output-dir'] ?? process.cwd();
+        const location = (0, node_path_1.resolve)(outputDir);
+        this.log(`Initializing oclif in ${(0, ansis_1.green)(location)}`);
+        const packageJSON = (await (0, generator_1.readPJSON)(location));
+        if (!packageJSON) {
+            throw new core_1.Errors.CLIError(`Could not find a package.json file in ${location}`);
+        }
+        const bin = await this.getFlagOrPrompt({
+            defaultValue: location.split(node_path_1.sep).at(-1) || '',
+            name: 'bin',
+            type: 'input',
+        });
+        const topicSeparator = await this.getFlagOrPrompt({
+            defaultValue: 'spaces',
+            name: 'topic-separator',
+            type: 'select',
+        });
+        const moduleType = await this.getFlagOrPrompt({
+            defaultValue: packageJSON.type === 'module' ? 'ESM' : 'CommonJS',
+            async maybeOtherValue() {
+                return packageJSON.type === 'module' ? 'ESM' : packageJSON.type === 'commonjs' ? 'CommonJS' : undefined;
+            },
+            name: 'module-type',
+            type: 'select',
+        });
+        const packageManager = await this.getFlagOrPrompt({
+            defaultValue: 'npm',
+            async maybeOtherValue() {
+                const rootFiles = await (0, promises_1.readdir)(location);
+                if (rootFiles.includes('package-lock.json')) {
+                    return 'npm';
+                }
+                if (rootFiles.includes('yarn.lock')) {
+                    return 'yarn';
+                }
+                if (rootFiles.includes('pnpm-lock.yaml')) {
+                    return 'pnpm';
+                }
+            },
+            name: 'package-manager',
+            type: 'select',
+        });
+        this.log(`Using module type ${(0, ansis_1.green)(moduleType)}`);
+        this.log(`Using package manager ${(0, ansis_1.green)(packageManager)}`);
+        const projectBinPath = (0, node_path_1.join)(location, 'bin');
+        const templateBinPath = (0, node_path_1.join)(this.templatesDir, 'cli', moduleType.toLowerCase(), 'bin');
+        await this.template((0, node_path_1.join)(templateBinPath, 'dev.cmd.ejs'), (0, node_path_1.join)(projectBinPath, 'dev.cmd'));
+        await this.template((0, node_path_1.join)(templateBinPath, 'dev.js.ejs'), (0, node_path_1.join)(projectBinPath, 'dev.js'));
+        await this.template((0, node_path_1.join)(templateBinPath, 'run.cmd.ejs'), (0, node_path_1.join)(projectBinPath, 'run.cmd'));
+        await this.template((0, node_path_1.join)(templateBinPath, 'run.js.ejs'), (0, node_path_1.join)(projectBinPath, 'run.js'));
+        if (process.platform !== 'win32') {
+            await (0, generator_1.exec)(`chmod +x "${(0, node_path_1.join)(projectBinPath, 'run.js')}"`);
+            await (0, generator_1.exec)(`chmod +x "${(0, node_path_1.join)(projectBinPath, 'dev.js')}"`);
+        }
+        const updatedPackageJSON = {
+            ...packageJSON,
+            bin: {
+                ...packageJSON.bin,
+                [bin]: './bin/run.js',
+            },
+            oclif: {
+                bin,
+                commands: './dist/commands',
+                dirname: bin,
+                topicSeparator: topicSeparator === 'colons' ? ':' : ' ',
+                ...packageJSON.oclif,
+            },
+        };
+        await (0, promises_1.writeFile)((0, node_path_1.join)(location, 'package.json'), JSON.stringify(updatedPackageJSON, null, 2));
+        const installedDeps = Object.keys(packageJSON.dependencies ?? {});
+        if (!installedDeps.includes('@oclif/core')) {
+            this.log('Installing @oclif/core');
+            await (0, generator_1.exec)(`${packageManager} ${packageManager === 'yarn' ? 'add' : 'install'} @oclif/core`, {
+                cwd: location,
+                silent: false,
+            });
+        }
+        const allInstalledDeps = new Set([...installedDeps, ...Object.keys(packageJSON.devDependencies ?? {})]);
+        if (!allInstalledDeps.has('ts-node')) {
+            this.log('Installing ts-node');
+            await (0, generator_1.exec)(`${packageManager} ${packageManager === 'yarn' ? 'add --dev' : 'install --save-dev'} ts-node`, {
+                cwd: location,
+                silent: false,
+            });
+        }
+        if (!allInstalledDeps.has('@types/node')) {
+            this.log('@types/node');
+            await (0, generator_1.exec)(`${packageManager} ${packageManager === 'yarn' ? 'add --dev' : 'install --save-dev'} @types/node@^18`, {
+                cwd: location,
+                silent: false,
+            });
+        }
+        this.log(`\nCreated CLI ${(0, ansis_1.green)(bin)}`);
+    }
+}
+exports.default = Generate;

package/lib/commands/lock.d.ts

@@ -0,0 +1,4 @@
+import { Command } from '@oclif/core';
+export default class Lock extends Command {
+    run(): Promise<void>;
+}

package/lib/commands/lock.js

@@ -0,0 +1,70 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const fs = __importStar(require("node:fs/promises"));
+const fileExists = async (path) => {
+    try {
+        await fs.access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+class Lock extends core_1.Command {
+    async run() {
+        if (await fileExists('yarn.lock')) {
+            this.log('Copying yarn.lock to oclif.lock');
+            await fs.copyFile('yarn.lock', 'oclif.lock');
+        }
+        else {
+            throw this.error('yarn.lock does not exist');
+        }
+    }
+    static {
+        this.hidden = true;
+        this.state = 'deprecated';
+        this.summary = 'Copy the yarn.lock to oclif.lock';
+        this.deprecationOptions = {
+            message: 'oclif.lock is deprecated and will be removed in @oclif/plugin-plugins v5.0.0 and above.',
+        };
+        this.description = `Using oclif.lock allows your plugins dependencies to be locked to the version specified in the lock file during plugin install.
+Once the oclif.lock file is created you can include it your npm package by adding it to the files property of your package.json. We do not recommend committing the oclif.lock file to git.
+
+PLEASE NOTE: the oclif.lock will only work for @oclif/plugin-plugins v3.4.0 and above. It will NOT be supported in v5.0.0 and above.`;
+    }
+}
+exports.default = Lock;

package/lib/commands/manifest.d.ts

@@ -0,0 +1,13 @@
+import { Command, Interfaces } from '@oclif/core';
+export default class Manifest extends Command {
+    static args: {
+        path: Interfaces.Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static flags: {
+        jit: Interfaces.BooleanFlag<boolean>;
+    };
+    run(): Promise<Interfaces.Manifest>;
+    private downloadTarball;
+    private executeCommand;
+}