@oclif/plugin-command-snapshot 3.0.0

package/CHANGELOG.md

@@ -0,0 +1,50 @@
+# Changelog
+
+All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
+
+### [2.2.2](https://github.com/oclif/plugin-command-snapshot/compare/v2.2.1...v2.2.2) (2021-06-30)
+
+
+### Bug Fixes
+
+* dont fail if schemas folder isn't found ([b12dc79](https://github.com/oclif/plugin-command-snapshot/commit/b12dc796619fe2469b2b4ea8fc524f999b1c614e))
+
+### [2.2.1](https://github.com/oclif/plugin-command-snapshot/compare/v2.2.0...v2.2.1) (2021-06-30)
+
+
+### Bug Fixes
+
+* allow for empty schemas dir ([bf3d74e](https://github.com/oclif/plugin-command-snapshot/commit/bf3d74e3c071ef524402e1bdb20e50cbff990b80))
+
+## [2.2.0](https://github.com/oclif/plugin-command-snapshot/compare/v2.1.2...v2.2.0) (2021-06-30)
+
+
+### Features
+
+* add --ignorevoid flag to schema:generate ([9c4a48e](https://github.com/oclif/plugin-command-snapshot/commit/9c4a48e076e750c2320a47bc4b7c2f4bfc7029ae))
+
+### [2.1.2](https://github.com/oclif/plugin-command-snapshot/compare/v2.1.1...v2.1.2) (2021-06-07)
+
+
+### Bug Fixes
+
+* disallow void return type ([4655cfd](https://github.com/oclif/plugin-command-snapshot/commit/4655cfd86eb1429c6b0a8b036bb22e43336b6e09))
+
+### [2.1.1](https://github.com/oclif/plugin-command-snapshot/compare/v2.1.0...v2.1.1) (2021-06-04)
+
+
+### Bug Fixes
+
+* ensure lib files are published ([c54b061](https://github.com/oclif/plugin-command-snapshot/commit/c54b06183aa39eaed60869421d3dd02e90fa27c0))
+
+## [2.1.0](https://github.com/oclif/plugin-command-snapshot/compare/v2.0.0...v2.1.0) (2021-06-03)
+
+
+### Features
+
+* add commands for generating and comparing JSON schemas ([#90](https://github.com/oclif/plugin-command-snapshot/issues/90)) ([0e31395](https://github.com/oclif/plugin-command-snapshot/commit/0e313950317179383786d939591d5e03116e5c27))
+
+
+### Bug Fixes
+
+* update return type for schema:generate ([36d99b3](https://github.com/oclif/plugin-command-snapshot/commit/36d99b3dc3d325c5ed81ea88f818f8ab59a67470))

package/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.

package/README.md

@@ -0,0 +1,43 @@
+@oclif/plugin-command-snapshot
+========
+
+Generates and compares OCLIF plugins snapshot files
+
+[![oclif](https://img.shields.io/badge/cli-oclif-brightgreen.svg)](https://oclif.io)
+[![Version](https://img.shields.io/npm/v/@oclif/plugin-command-snapshot.svg)](https://npmjs.org/package/@oclif/plugin-command-snapshot)
+[![Downloads/week](https://img.shields.io/npm/dw/@oclif/plugin-command-snapshot.svg)](https://npmjs.org/package/@oclif/plugin-command-snapshot)
+[![License](https://img.shields.io/npm/l/@oclif/plugin-command-snapshot.svg)](https://github.com/nramyasri-sf/@oclif/plugin-command-snapshot/blob/master/package.json)
+
+<!-- toc -->
+* [Usage](#usage)
+* [generates a snapshot file that has a list or commands and flags in the current CLI or plugin](#generates-a-snapshot-file-that-has-a-list-or-commands-and-flags-in-the-current-cli-or-plugin)
+* [compare the current CLI or plugin commands and flags with a snapshot file to identify changes](#compare-the-current-cli-or-plugin-commands-and-flags-with-a-snapshot-file-to-identify-changes)
+<!-- tocstop -->
+
+# Usage
+This plugin is used to take snapshot of commands and flags in OCLIF plugins. These snapshots can be used to enforce a deprecation policy or to keep track of changes.
+
+To include it in your plugin, add it to the `devPlugins` section in your package.json.
+
+```json
+"oclif": {
+    ...
+    "devPlugins": [
+      "@oclif/plugin-command-snapshot"
+      ...
+    ]
+```
+
+Use the `snapshot:generate` command in your development process.
+
+```sh-session
+# generates a snapshot file that has a list or commands and flags in the current CLI or plugin
+$ ./bin/run snapshot:generate
+```
+
+Use the `snapshot:compare` command in your continuos integration. This command will fail if changes are detected. The snapshot file should be updated and committed to the repository when legitimate changes are made.
+
+```sh-session
+# compare the current CLI or plugin commands and flags with a snapshot file to identify changes
+$ ./bin/run snapshot:compare
+```

package/lib/commands/schema/compare.d.ts

@@ -0,0 +1,15 @@
+import { Operation } from 'just-diff';
+import { SnapshotCommand } from '../../snapshot-command';
+export declare type SchemaComparison = Array<{
+    op: Operation;
+    path: (string | number)[];
+    value: any;
+}>;
+export default class SchemaCompare extends SnapshotCommand {
+    static flags: {
+        filepath: import("@oclif/core/lib/interfaces").OptionFlag<string>;
+    };
+    run(): Promise<SchemaComparison>;
+    private readExistingSchema;
+    private generateLatestSchema;
+}

package/lib/commands/schema/compare.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = require("path");
+const fs = require("fs");
+const semver = require("semver");
+const _ = require("lodash");
+const just_diff_1 = require("just-diff");
+const core_1 = require("@oclif/core");
+const snapshot_command_1 = require("../../snapshot-command");
+const generate_1 = require("./generate");
+const chalk_1 = require("chalk");
+class SchemaCompare extends snapshot_command_1.SnapshotCommand {
+    async run() {
+        const { flags } = await this.parse(SchemaCompare);
+        try {
+            fs.accessSync(flags.filepath);
+        }
+        catch (_a) {
+            this.log(`${flags.filepath} not found.`);
+            return [];
+        }
+        const existingSchema = this.readExistingSchema(flags.filepath);
+        const latestSchema = await this.generateLatestSchema();
+        const changes = just_diff_1.diff(latestSchema, existingSchema);
+        if (changes.length === 0) {
+            this.log('No changes have been detected.');
+            return [];
+        }
+        const humandReadableChanges = {};
+        for (const change of changes) {
+            const objPath = change.path.join('.');
+            const existing = _.get(existingSchema, objPath);
+            const latest = _.get(latestSchema, objPath);
+            const [commandId] = objPath.split('.definitions');
+            const readablePath = objPath.replace(`${commandId}.`, '');
+            if (!humandReadableChanges[commandId]) {
+                humandReadableChanges[commandId] = [];
+            }
+            switch (change.op) {
+                case 'replace':
+                    humandReadableChanges[commandId].push(`${chalk_1.underline(readablePath)} was changed from ${chalk_1.cyan(existing)} to ${chalk_1.cyan(latest)}`);
+                    break;
+                case 'add':
+                    humandReadableChanges[commandId].push(`${chalk_1.underline(readablePath)} was ${chalk_1.cyan('added')} to latest schema`);
+                    break;
+                case 'remove':
+                    humandReadableChanges[commandId].push(`${chalk_1.underline(readablePath)} was ${chalk_1.cyan('removed')} from latest schema`);
+                    break;
+                default:
+                    break;
+            }
+        }
+        this.log();
+        this.log(chalk_1.bold(chalk_1.red('Found the following schema changes:')));
+        for (const [commandId, changes] of Object.entries(humandReadableChanges)) {
+            this.log();
+            this.log(chalk_1.bold(commandId));
+            for (const change of changes) {
+                this.log(`  - ${change}`);
+            }
+        }
+        this.log();
+        this.log('If intended, please update the schema file(s) and run again.');
+        process.exitCode = 1;
+        return changes;
+    }
+    readExistingSchema(filePath) {
+        const contents = fs.readdirSync(filePath);
+        const folderIsVersioned = contents.every(c => semver.valid(c));
+        const schemasDir = folderIsVersioned ? path.join(filePath, semver.rsort(contents)[0] || '') : filePath;
+        const schemaFiles = fs.readdirSync(schemasDir).map(f => path.join(schemasDir, f)).filter(f => !fs.statSync(f).isDirectory());
+        let schemas = {};
+        if (schemaFiles.length === 1 && schemaFiles[0].endsWith('schema.json')) {
+            schemas = JSON.parse(fs.readFileSync(schemaFiles[0]).toString('utf8'));
+        }
+        else {
+            for (const file of schemaFiles) {
+                const schema = JSON.parse(fs.readFileSync(file).toString('utf8'));
+                schemas[path.basename(file.replace(/-/g, ':')).replace('.json', '')] = schema;
+            }
+        }
+        return schemas;
+    }
+    async generateLatestSchema() {
+        const generator = new generate_1.SchemaGenerator(this);
+        return generator.generate();
+    }
+}
+exports.default = SchemaCompare;
+SchemaCompare.flags = {
+    filepath: core_1.Flags.string({
+        description: 'path of the generated snapshot file',
+        default: './schemas',
+    }),
+};

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

@@ -0,0 +1,25 @@
+import { Schema } from 'ts-json-schema-generator';
+import { SnapshotCommand } from '../../snapshot-command';
+export declare type SchemasMap = {
+    [key: string]: Schema;
+};
+export declare type GenerateResponse = string[];
+export declare class SchemaGenerator {
+    private base;
+    private ignorevoid;
+    private classToId;
+    constructor(base: SnapshotCommand, ignorevoid?: boolean);
+    generate(): Promise<SchemasMap>;
+    private getAllCmdFiles;
+    private parseFile;
+    private validateReturnType;
+    private determineCommandId;
+}
+export default class SchemaGenerate extends SnapshotCommand {
+    static flags: {
+        filepath: import("@oclif/core/lib/interfaces").OptionFlag<string>;
+        singlefile: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        ignorevoid: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<GenerateResponse>;
+}

package/lib/commands/schema/generate.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchemaGenerator = void 0;
+const path = require("path");
+const fs = require("fs");
+const core_1 = require("@oclif/core");
+const ts_json_schema_generator_1 = require("ts-json-schema-generator");
+const snapshot_command_1 = require("../../snapshot-command");
+const chalk_1 = require("chalk");
+class SchemaGenerator {
+    constructor(base, ignorevoid = true) {
+        this.base = base;
+        this.ignorevoid = ignorevoid;
+        this.classToId = {};
+    }
+    async generate() {
+        for (const cmd of this.base.commands) {
+            // eslint-disable-next-line no-await-in-loop
+            const loadedCmd = await cmd.load(); // commands are loaded async in oclif/core
+            this.classToId[loadedCmd.name] = loadedCmd.id;
+        }
+        const schemas = {};
+        for (const file of this.getAllCmdFiles()) {
+            const { returnType, commandId } = this.parseFile(file);
+            if (this.ignorevoid && returnType === 'void')
+                continue;
+            try {
+                const config = {
+                    path: file,
+                    type: returnType,
+                    skipTypeCheck: true,
+                };
+                const schema = ts_json_schema_generator_1.createGenerator(config).createSchema(config.type);
+                schemas[commandId] = schema;
+            }
+            catch (error) {
+                if (error.message.toLowerCase().includes('no root type')) {
+                    throw new Error(`Schema generator could not find the ${chalk_1.red(returnType)} type. Please make sure that ${chalk_1.red(returnType)} is exported.`);
+                }
+                else {
+                    throw error;
+                }
+            }
+        }
+        return schemas;
+    }
+    getAllCmdFiles(dirPath = path.join(this.base.config.root, 'src', 'commands'), allFiles = []) {
+        const files = fs.readdirSync(dirPath);
+        files.forEach(file => {
+            const fPath = path.join(dirPath, file);
+            if (fs.statSync(fPath).isDirectory()) {
+                allFiles = this.getAllCmdFiles(fPath, allFiles);
+            }
+            else if (file.endsWith('ts')) {
+                allFiles.push(fPath);
+            }
+        });
+        return allFiles;
+    }
+    parseFile(file) {
+        const returnTypeRegex = /(?<=async\srun\(\):\sPromise<)(.*?)(>*)(?=>)/g;
+        const contents = fs.readFileSync(file, 'utf8');
+        const [returnType] = returnTypeRegex.exec(contents) || [];
+        if (!returnType) {
+            throw new Error(`No return type found for file ${file}`);
+        }
+        const commandId = this.determineCommandId(contents);
+        if (!commandId) {
+            throw new Error(`No commandId found for file ${file}`);
+        }
+        this.validateReturnType(returnType, commandId);
+        return { returnType, commandId };
+    }
+    validateReturnType(returnType, commandId) {
+        const notAllowed = this.ignorevoid ? ['any', 'unknown'] : ['any', 'unknown', 'void'];
+        const vaugeTypes = ['JsonMap', 'JsonCollection', 'AnyJson'];
+        if (notAllowed.includes(returnType)) {
+            throw new Error(`${returnType} (from ${commandId}) is not allowed. Please use a more specific type.`);
+        }
+        else if (vaugeTypes.includes(returnType)) {
+            throw new Error(`${returnType} (from ${commandId}) is too vauge. Please use a more specific type.`);
+        }
+    }
+    determineCommandId(contents) {
+        for (const [className, cmdId] of Object.entries(this.classToId)) {
+            const regex = new RegExp(` class ${className} `, 'g');
+            if (regex.test(contents)) {
+                return cmdId;
+            }
+        }
+    }
+}
+exports.SchemaGenerator = SchemaGenerator;
+class SchemaGenerate extends snapshot_command_1.SnapshotCommand {
+    async run() {
+        const { flags } = await this.parse(SchemaGenerate);
+        const generator = new SchemaGenerator(this, flags.ignorevoid);
+        const schemas = await generator.generate();
+        const directory = flags.filepath.replace('{version}', this.config.version);
+        fs.mkdirSync(directory, { recursive: true });
+        const files = [];
+        if (flags.singlefile) {
+            const filePath = path.join(directory, 'schema.json');
+            fs.writeFileSync(filePath, JSON.stringify(schemas, null, 2));
+            this.log(`Generated JSON schema file "${filePath}"`);
+            files.push(filePath);
+        }
+        else {
+            for (const [cmdId, schema] of Object.entries(schemas)) {
+                const fileName = `${cmdId.replace(/:/g, '-')}.json`;
+                const filePath = path.join(directory, fileName);
+                fs.writeFileSync(filePath, JSON.stringify(schema, null, 2));
+                this.log(`Generated JSON schema file "${filePath}"`);
+                files.push(filePath);
+            }
+        }
+        return files;
+    }
+}
+exports.default = SchemaGenerate;
+SchemaGenerate.flags = {
+    filepath: core_1.Flags.string({
+        description: 'directory to save the generated schema files; can use "{version}" to insert the current CLI/plugin version',
+        default: './schemas',
+    }),
+    singlefile: core_1.Flags.boolean({
+        description: 'put generated schema into a single file',
+        default: false,
+    }),
+    ignorevoid: core_1.Flags.boolean({
+        description: 'ignore commands that return void',
+        default: true,
+    }),
+};

package/lib/commands/snapshot/compare.d.ts

@@ -0,0 +1,44 @@
+import { SnapshotCommand, SnapshotEntry } from '../../snapshot-command';
+interface Change {
+    name: string;
+    removed?: boolean;
+    added?: boolean;
+}
+declare type CommandChange = {
+    plugin: string;
+    flags: Change[];
+} & Change;
+export declare type CompareResponse = {
+    addedCommands?: string[];
+    removedCommands?: string[];
+    removedFlags?: string[];
+    diffCommands?: CommandChange[];
+};
+export default class Compare extends SnapshotCommand {
+    static flags: {
+        filepath: import("@oclif/core/lib/interfaces").OptionFlag<string>;
+    };
+    /**
+     * Compare a snapshot with the current commands
+     * @param {CommandChange[]} initialCommands Command list from the snapshot
+     * @param {CommandChange[]} updatedCommands Command list from runtime
+     * @returns all the command differences
+     */
+    compareSnapshot(initialCommands: SnapshotEntry[], updatedCommands: CommandChange[]): Promise<CompareResponse>;
+    /**
+     * Compares a flag snapshot with the current command's flags
+     * @param {string[]} initialFlags Flag list from the snapshot
+     * @param {string[]} updatedFlags Flag list from runtime
+     * @param {string} initialCommand Command the flags belong to
+     * @return {boolean} true if no changes, false otherwise
+     */
+    diffCommandFlags(initialFlags: string[], updatedFlags: Change[]): {
+        addedFlags: string[];
+        removedFlags: string[];
+        updatedFlags: Change[];
+        changedFlags: Change[];
+    };
+    get changed(): CommandChange[];
+    run(): Promise<CompareResponse>;
+}
+export {};

package/lib/commands/snapshot/compare.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const _ = require("lodash");
+const fs = require("fs");
+const os_1 = require("os");
+const snapshot_command_1 = require("../../snapshot-command");
+const chalk = require("chalk");
+class Compare extends snapshot_command_1.SnapshotCommand {
+    /**
+     * Compare a snapshot with the current commands
+     * @param {CommandChange[]} initialCommands Command list from the snapshot
+     * @param {CommandChange[]} updatedCommands Command list from runtime
+     * @returns all the command differences
+     */
+    async compareSnapshot(initialCommands, updatedCommands) {
+        const removedCommands = [];
+        const diffCommands = [];
+        initialCommands.forEach(initialCommand => {
+            const updatedCommand = updatedCommands.find(updatedCommand => {
+                // Protect against old snapshot files that don't have the plugin entry filled out.
+                const samePlugin = initialCommand.plugin ? initialCommand.plugin === updatedCommand.plugin : true;
+                return initialCommand.command === updatedCommand.name && samePlugin;
+            });
+            if (updatedCommand) {
+                const { changedFlags } = this.diffCommandFlags(initialCommand.flags, updatedCommand.flags);
+                if (changedFlags.length > 0) {
+                    diffCommands.push(updatedCommand);
+                }
+            }
+            else {
+                removedCommands.push(initialCommand.command);
+            }
+        });
+        const initialCommandNames = initialCommands.map(initialCommand => initialCommand.command);
+        const updatedCommandNames = updatedCommands.map(updatedCommand => updatedCommand.name);
+        const addedCommands = _.difference(updatedCommandNames, initialCommandNames);
+        if (removedCommands.length === 0 && addedCommands.length === 0 && diffCommands.length === 0) {
+            this.log('No changes have been detected.');
+            return {};
+        }
+        // Fail the process since there are changes to the snapshot file
+        process.exitCode = 1;
+        this.log(`The following commands and flags have modified: (${chalk.green('+')} added, ${chalk.red('-')} removed)${os_1.EOL}`);
+        removedCommands.forEach(command => {
+            this.log(chalk.red(`\t-${command}`));
+        });
+        addedCommands.forEach(command => {
+            this.log(chalk.green(`\t+${command}`));
+        });
+        const removedFlags = [];
+        if (diffCommands.length > 0) {
+            diffCommands.forEach(command => {
+                this.log(`\t ${command.name}`);
+                command.flags.forEach(flag => {
+                    if (flag.added || flag.removed) {
+                        const color = flag.added ? chalk.green : chalk.red;
+                        this.log(color(`\t\t${flag.added ? '+' : '-'}${flag.name}`));
+                    }
+                    if (flag.removed)
+                        removedFlags.push();
+                });
+            });
+        }
+        this.log(`${os_1.EOL}Command or flag differences detected. If intended, please update the snapshot file and run again.`);
+        // Check if existent commands have been deleted
+        if (removedCommands.length > 0 || removedFlags.length > 0) {
+            this.log(chalk.red(`${os_1.EOL}Since there are deletions, a major version bump is required.`));
+        }
+        return { addedCommands, removedCommands, removedFlags, diffCommands };
+    }
+    /**
+     * Compares a flag snapshot with the current command's flags
+     * @param {string[]} initialFlags Flag list from the snapshot
+     * @param {string[]} updatedFlags Flag list from runtime
+     * @param {string} initialCommand Command the flags belong to
+     * @return {boolean} true if no changes, false otherwise
+     */
+    diffCommandFlags(initialFlags, updatedFlags) {
+        const updatedFlagNames = updatedFlags.map(updatedFlag => updatedFlag.name);
+        const addedFlags = _.difference(updatedFlagNames, initialFlags);
+        const removedFlags = _.difference(initialFlags, updatedFlagNames);
+        const changedFlags = [];
+        updatedFlags.forEach(updatedFlag => {
+            if (addedFlags.includes(updatedFlag.name)) {
+                updatedFlag.added = true;
+                changedFlags.push(updatedFlag);
+            }
+        });
+        removedFlags.forEach(removedFlag => {
+            changedFlags.push({ name: removedFlag, removed: true });
+            // The removed flags in not included in the updated flags, but we want it to
+            // so it shows removed.
+            updatedFlags.push({ name: removedFlag, removed: true });
+        });
+        return { addedFlags, removedFlags, updatedFlags, changedFlags };
+    }
+    get changed() {
+        return this.commands.map(command => {
+            return {
+                name: command.id,
+                plugin: command.pluginName || '',
+                flags: Object.entries(command.flags).map(flagName => ({ name: flagName[0] })),
+            };
+        });
+    }
+    async run() {
+        const { flags } = await this.parse(Compare);
+        const oldCommandFlags = JSON.parse(fs.readFileSync(flags.filepath).toString('utf8'));
+        const resultnewCommandFlags = this.changed;
+        return this.compareSnapshot(oldCommandFlags, resultnewCommandFlags);
+    }
+}
+exports.default = Compare;
+Compare.flags = {
+    filepath: core_1.Flags.string({
+        description: 'path of the generated snapshot file',
+        default: './command-snapshot.json',
+    }),
+};

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

@@ -0,0 +1,12 @@
+import { SnapshotCommand } from '../../snapshot-command';
+export declare type Snapshots = {
+    command: string;
+    plugin: string;
+    flags: string[];
+}[];
+export default class Generate extends SnapshotCommand {
+    static flags: {
+        filepath: import("@oclif/core/lib/interfaces").OptionFlag<string>;
+    };
+    run(): Promise<Snapshots>;
+}

package/lib/commands/snapshot/generate.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const fs = require("fs");
+const snapshot_command_1 = require("../../snapshot-command");
+class Generate extends snapshot_command_1.SnapshotCommand {
+    async run() {
+        const numberOfSpaceChar = 4;
+        const { flags } = await this.parse(Generate);
+        const resultCommands = this.entries;
+        const filePath = flags.filepath.replace('{version}', this.config.version);
+        fs.writeFileSync(filePath, JSON.stringify(resultCommands, null, numberOfSpaceChar));
+        this.log(`Generated snapshot file "${filePath}"`);
+        return resultCommands;
+    }
+}
+exports.default = Generate;
+Generate.flags = {
+    filepath: core_1.Flags.string({
+        description: 'path to save the generated snapshot file; can use "{version}" to replace the current CLI/plugin version',
+        default: './command-snapshot.json',
+    }),
+};

package/lib/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: {};
+export default _default;

package/lib/index.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {};

package/lib/snapshot-command.d.ts

@@ -0,0 +1,10 @@
+import { Command } from '@oclif/core';
+export declare type SnapshotEntry = {
+    command: string;
+    plugin: string;
+    flags: string[];
+};
+export declare abstract class SnapshotCommand extends Command {
+    get commands(): import("@oclif/core/lib/interfaces").Command.Plugin[];
+    get entries(): SnapshotEntry[];
+}

package/lib/snapshot-command.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SnapshotCommand = void 0;
+const core_1 = require("@oclif/core");
+const _ = require("lodash");
+class SnapshotCommand extends core_1.Command {
+    get commands() {
+        var _a;
+        const devPlugins = (_a = this.config.pjson.oclif.devPlugins) !== null && _a !== void 0 ? _a : [];
+        const commands = this.config.commands
+            // Ignore dev plugins
+            .filter(command => { var _a; return !devPlugins.includes((_a = command.pluginName) !== null && _a !== void 0 ? _a : ''); });
+        return _.sortBy(commands, 'id');
+    }
+    get entries() {
+        return this.commands.map(command => {
+            return {
+                command: command.id,
+                plugin: command.pluginName,
+                flags: Object.keys(command.flags).sort(),
+            };
+        });
+    }
+}
+exports.SnapshotCommand = SnapshotCommand;

package/oclif.manifest.json

@@ -0,0 +1 @@
+{"version":"3.0.0","commands":{"schema:compare":{"id":"schema:compare","strict":true,"pluginName":"@oclif/plugin-command-snapshot","pluginAlias":"@oclif/plugin-command-snapshot","pluginType":"core","aliases":[],"flags":{"filepath":{"name":"filepath","type":"option","description":"path of the generated snapshot file","multiple":false,"default":"./schemas"}},"args":[]},"schema:generate":{"id":"schema:generate","strict":true,"pluginName":"@oclif/plugin-command-snapshot","pluginAlias":"@oclif/plugin-command-snapshot","pluginType":"core","aliases":[],"flags":{"filepath":{"name":"filepath","type":"option","description":"directory to save the generated schema files; can use \"{version}\" to insert the current CLI/plugin version","multiple":false,"default":"./schemas"},"singlefile":{"name":"singlefile","type":"boolean","description":"put generated schema into a single file","allowNo":false},"ignorevoid":{"name":"ignorevoid","type":"boolean","description":"ignore commands that return void","allowNo":false}},"args":[]},"snapshot:compare":{"id":"snapshot:compare","strict":true,"pluginName":"@oclif/plugin-command-snapshot","pluginAlias":"@oclif/plugin-command-snapshot","pluginType":"core","aliases":[],"flags":{"filepath":{"name":"filepath","type":"option","description":"path of the generated snapshot file","multiple":false,"default":"./command-snapshot.json"}},"args":[]},"snapshot:generate":{"id":"snapshot:generate","strict":true,"pluginName":"@oclif/plugin-command-snapshot","pluginAlias":"@oclif/plugin-command-snapshot","pluginType":"core","aliases":[],"flags":{"filepath":{"name":"filepath","type":"option","description":"path to save the generated snapshot file; can use \"{version}\" to replace the current CLI/plugin version","multiple":false,"default":"./command-snapshot.json"}},"args":[]}}}