@oclif/plugin-command-snapshot 3.0.0 → 3.1.3

package/CHANGELOG.md

@@ -2,6 +2,40 @@
 
 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.
 
+### [3.1.3](https://github.com/oclif/plugin-command-snapshot/compare/v3.1.2...v3.1.3) (2022-02-14)
+
+
+### Bug Fixes
+
+* bump demps ([c2643c7](https://github.com/oclif/plugin-command-snapshot/commit/c2643c745aa121677be1bac60547180ba406b8e4))
+
+### [3.1.2](https://github.com/oclif/plugin-command-snapshot/compare/v3.1.1...v3.1.2) (2021-11-10)
+
+
+### Bug Fixes
+
+* adds alias property to command-snapshot \n BREAKING CHANGE: this changes the output of the file of the command snapshot which will cause compare to fail ([dea464e](https://github.com/oclif/plugin-command-snapshot/commit/dea464e17c11efd6a777982f4689bfc41f6ce9bd))
+
+### [3.1.1](https://github.com/oclif/plugin-command-snapshot/compare/v3.1.0...v3.1.1) (2021-10-11)
+
+
+### Bug Fixes
+
+* update hook regex ([#144](https://github.com/oclif/plugin-command-snapshot/issues/144)) ([dc1225c](https://github.com/oclif/plugin-command-snapshot/commit/dc1225cc22e071958436e320b8951063b038d4cc))
+
+## [3.1.0](https://github.com/oclif/plugin-command-snapshot/compare/v3.0.0...v3.1.0) (2021-10-08)
+
+
+### Features
+
+* generate schema for hooks ([266b832](https://github.com/oclif/plugin-command-snapshot/commit/266b83242fab1961b036998119791b999a08ee19))
+
+
+### Bug Fixes
+
+* ignore hooks with no return type ([070ed41](https://github.com/oclif/plugin-command-snapshot/commit/070ed41902268d48034fdaa2b96f9a4a54eefd2c))
+* schema:compare with hooks ([508549a](https://github.com/oclif/plugin-command-snapshot/commit/508549a372e56b3d79dec970e62477d9905dec13))
+
 ### [2.2.2](https://github.com/oclif/plugin-command-snapshot/compare/v2.2.1...v2.2.2) (2021-06-30)
 
 

package/README.md

@@ -6,7 +6,7 @@ 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)
+[![License](https://img.shields.io/npm/l/@oclif/plugin-command-snapshot.svg)](https://github.com/nramyasri-sf/@oclif/plugin-command-snapshot/blob/main/package.json)
 
 <!-- toc -->
 * [Usage](#usage)

package/lib/commands/schema/compare.js

@@ -20,8 +20,10 @@ class SchemaCompare extends snapshot_command_1.SnapshotCommand {
             return [];
         }
         const existingSchema = this.readExistingSchema(flags.filepath);
-        const latestSchema = await this.generateLatestSchema();
-        const changes = just_diff_1.diff(latestSchema, existingSchema);
+        const latestSchema = (await this.generateLatestSchema());
+        this.debug('existingSchema', existingSchema);
+        this.debug('latestSchema', latestSchema);
+        const changes = (0, just_diff_1.diff)(latestSchema, existingSchema);
         if (changes.length === 0) {
             this.log('No changes have been detected.');
             return [];
@@ -38,23 +40,23 @@ class SchemaCompare extends snapshot_command_1.SnapshotCommand {
             }
             switch (change.op) {
                 case 'replace':
-                    humandReadableChanges[commandId].push(`${chalk_1.underline(readablePath)} was changed from ${chalk_1.cyan(existing)} to ${chalk_1.cyan(latest)}`);
+                    humandReadableChanges[commandId].push(`${(0, chalk_1.underline)(readablePath)} was changed from ${(0, chalk_1.cyan)(existing)} to ${(0, chalk_1.cyan)(latest)}`);
                     break;
                 case 'add':
-                    humandReadableChanges[commandId].push(`${chalk_1.underline(readablePath)} was ${chalk_1.cyan('added')} to latest schema`);
+                    humandReadableChanges[commandId].push(`${(0, chalk_1.underline)(readablePath)} was ${(0, 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`);
+                    humandReadableChanges[commandId].push(`${(0, chalk_1.underline)(readablePath)} was ${(0, chalk_1.cyan)('not found')} in latest schema`);
                     break;
                 default:
                     break;
             }
         }
         this.log();
-        this.log(chalk_1.bold(chalk_1.red('Found the following schema changes:')));
+        this.log((0, chalk_1.bold)((0, chalk_1.red)('Found the following schema changes:')));
         for (const [commandId, changes] of Object.entries(humandReadableChanges)) {
             this.log();
-            this.log(chalk_1.bold(commandId));
+            this.log((0, chalk_1.bold)(commandId));
             for (const change of changes) {
                 this.log(`  - ${change}`);
             }
@@ -68,15 +70,24 @@ class SchemaCompare extends snapshot_command_1.SnapshotCommand {
         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 = {};
+        const schemaFiles = (0, generate_1.getAllFiles)(schemasDir, '.json');
+        let schemas = {
+            commands: {},
+            hooks: {},
+        };
         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;
+                const key = path.basename(file.replace(/-/g, ':')).replace('.json', '');
+                if (file.split(path.sep).includes('hooks')) {
+                    schemas.hooks[key] = schema;
+                }
+                else {
+                    schemas.commands[key] = schema;
+                }
             }
         }
         return schemas;

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

@@ -3,17 +3,37 @@ import { SnapshotCommand } from '../../snapshot-command';
 export declare type SchemasMap = {
     [key: string]: Schema;
 };
+export declare type Schemas = {
+    commands: SchemasMap;
+    hooks: SchemasMap;
+};
 export declare type GenerateResponse = string[];
+export declare function getAllFiles(dirPath: string, ext: string, allFiles?: string[]): string[];
 export declare class SchemaGenerator {
     private base;
     private ignorevoid;
     private classToId;
     constructor(base: SnapshotCommand, ignorevoid?: boolean);
-    generate(): Promise<SchemasMap>;
+    generate(): Promise<Schemas>;
+    private generateSchema;
     private getAllCmdFiles;
-    private parseFile;
+    private getAllHookFiles;
+    /**
+     * Use regex to find the typescript type being returned by the command's
+     * `run` method.
+     * @param file the file to parse
+     * @returns Returns the name of the return type and the command id.
+     */
+    private parseCmdFile;
+    /**
+     * Use regex to find the typescript type being returned by the hook
+     * @param file the file to parse
+     * @returns Returns the name of the return type and the hook id.
+     */
+    private parseHookFile;
     private validateReturnType;
     private determineCommandId;
+    private getDirs;
 }
 export default class SchemaGenerate extends SnapshotCommand {
     static flags: {

package/lib/commands/schema/generate.js

@@ -1,12 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SchemaGenerator = void 0;
+exports.SchemaGenerator = exports.getAllFiles = 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");
+function getAllFiles(dirPath, ext, allFiles = []) {
+    let files = [];
+    try {
+        files = fs.readdirSync(dirPath);
+    }
+    catch (_a) { }
+    files.forEach(file => {
+        const fPath = path.join(dirPath, file);
+        if (fs.statSync(fPath).isDirectory()) {
+            allFiles = getAllFiles(fPath, ext, allFiles);
+        }
+        else if (file.endsWith(ext)) {
+            allFiles.push(fPath);
+        }
+    });
+    return allFiles;
+}
+exports.getAllFiles = getAllFiles;
 class SchemaGenerator {
     constructor(base, ignorevoid = true) {
         this.base = base;
@@ -19,45 +37,59 @@ class SchemaGenerator {
             const loadedCmd = await cmd.load(); // commands are loaded async in oclif/core
             this.classToId[loadedCmd.name] = loadedCmd.id;
         }
-        const schemas = {};
+        const cmdSchemas = {};
         for (const file of this.getAllCmdFiles()) {
-            const { returnType, commandId } = this.parseFile(file);
+            const { returnType, commandId } = this.parseCmdFile(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;
-                }
+            cmdSchemas[commandId] = this.generateSchema(returnType, file);
+        }
+        const hookSchemas = {};
+        for (const file of this.getAllHookFiles()) {
+            const { returnType, hookId } = this.parseHookFile(file);
+            if (returnType && hookId) {
+                hookSchemas[hookId] = this.generateSchema(returnType, file);
             }
         }
-        return schemas;
+        return { commands: cmdSchemas, hooks: hookSchemas };
     }
-    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);
+    generateSchema(returnType, file) {
+        try {
+            const config = {
+                path: file,
+                type: returnType,
+                skipTypeCheck: true,
+            };
+            return (0, ts_json_schema_generator_1.createGenerator)(config).createSchema(config.type);
+        }
+        catch (error) {
+            if (error.message.toLowerCase().includes('no root type')) {
+                throw new Error(`Schema generator could not find the ${(0, chalk_1.red)(returnType)} type. Please make sure that ${(0, chalk_1.red)(returnType)} is exported.`);
             }
-            else if (file.endsWith('ts')) {
-                allFiles.push(fPath);
+            else {
+                throw error;
             }
-        });
-        return allFiles;
+        }
+    }
+    getAllCmdFiles() {
+        const { rootDir } = this.getDirs();
+        return getAllFiles(path.join(rootDir, 'commands'), '.ts');
+    }
+    getAllHookFiles() {
+        var _a, _b;
+        const hookFiles = Object.values((_b = (_a = this.base.config.pjson.oclif) === null || _a === void 0 ? void 0 : _a.hooks) !== null && _b !== void 0 ? _b : {}).reduce((x, y) => {
+            return Array.isArray(y) ? x.concat(y) : x.concat([y]);
+        }, []);
+        const { rootDir, outDir } = this.getDirs();
+        return hookFiles.map(h => `${path.resolve(h)}.ts`.replace(outDir, rootDir));
     }
-    parseFile(file) {
+    /**
+     * Use regex to find the typescript type being returned by the command's
+     * `run` method.
+     * @param file the file to parse
+     * @returns Returns the name of the return type and the command id.
+     */
+    parseCmdFile(file) {
         const returnTypeRegex = /(?<=async\srun\(\):\sPromise<)(.*?)(>*)(?=>)/g;
         const contents = fs.readFileSync(file, 'utf8');
         const [returnType] = returnTypeRegex.exec(contents) || [];
@@ -71,6 +103,32 @@ class SchemaGenerator {
         this.validateReturnType(returnType, commandId);
         return { returnType, commandId };
     }
+    /**
+     * Use regex to find the typescript type being returned by the hook
+     * @param file the file to parse
+     * @returns Returns the name of the return type and the hook id.
+     */
+    parseHookFile(file) {
+        var _a, _b;
+        const returnTypeRegex = /(?<=const\shook:\s(.*?)<)[^'](.*?)[^'](>*)(?=>)/g;
+        const contents = fs.readFileSync(file, 'utf8');
+        const [returnType] = returnTypeRegex.exec(contents) || [];
+        if (!returnType || returnType === 'void') {
+            return { returnType: null, hookId: null };
+        }
+        const hooks = (_b = (_a = this.base.config.pjson.oclif) === null || _a === void 0 ? void 0 : _a.hooks) !== null && _b !== void 0 ? _b : {};
+        const hookId = Object.keys(hooks).find(key => {
+            const hookFiles = (Array.isArray(hooks[key]) ? hooks[key] : [hooks[key]]);
+            const hookFileNames = hookFiles.map(f => path.basename(f).split('.')[0]);
+            const currentFileName = path.basename(file).split('.')[0];
+            return hookFileNames.includes(currentFileName);
+        });
+        if (!hookId) {
+            return { returnType: null, hookId: null };
+        }
+        this.validateReturnType(returnType, hookId);
+        return { returnType, hookId };
+    }
     validateReturnType(returnType, commandId) {
         const notAllowed = this.ignorevoid ? ['any', 'unknown'] : ['any', 'unknown', 'void'];
         const vaugeTypes = ['JsonMap', 'JsonCollection', 'AnyJson'];
@@ -89,6 +147,24 @@ class SchemaGenerator {
             }
         }
     }
+    getDirs() {
+        const dirs = {
+            rootDir: path.join(this.base.config.root, 'src'),
+            outDir: path.join(this.base.config.root, 'lib'),
+        };
+        try {
+            const tsConfig = JSON.parse(fs.readFileSync(path.join(this.base.config.root, 'tsconfig.json'), 'utf-8'));
+            if (tsConfig.compilerOptions.rootDir) {
+                dirs.rootDir = path.join(this.base.config.root, tsConfig.compilerOptions.rootDir);
+            }
+            if (tsConfig.compilerOptions.outDir) {
+                dirs.outDir = path.join(this.base.config.root, tsConfig.compilerOptions.outDir);
+            }
+            return dirs;
+        }
+        catch (_a) { }
+        return dirs;
+    }
 }
 exports.SchemaGenerator = SchemaGenerator;
 class SchemaGenerate extends snapshot_command_1.SnapshotCommand {
@@ -106,13 +182,24 @@ class SchemaGenerate extends snapshot_command_1.SnapshotCommand {
             files.push(filePath);
         }
         else {
-            for (const [cmdId, schema] of Object.entries(schemas)) {
+            for (const [cmdId, schema] of Object.entries(schemas.commands)) {
                 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);
             }
+            if (Object.values(schemas.hooks).length > 0) {
+                const hooksDir = path.join(directory, 'hooks');
+                fs.mkdirSync(hooksDir, { recursive: true });
+                for (const [hookId, schema] of Object.entries(schemas.hooks)) {
+                    const fileName = `${hookId.replace(/:/g, '-')}.json`;
+                    const filePath = path.join(hooksDir, fileName);
+                    fs.writeFileSync(filePath, JSON.stringify(schema, null, 2));
+                    this.log(`Generated JSON schema file "${filePath}"`);
+                    files.push(filePath);
+                }
+            }
         }
         return files;
     }

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

@@ -7,6 +7,7 @@ interface Change {
 declare type CommandChange = {
     plugin: string;
     flags: Change[];
+    alias: Change[];
 } & Change;
 export declare type CompareResponse = {
     addedCommands?: string[];
@@ -26,18 +27,30 @@ export default class Compare extends SnapshotCommand {
      */
     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
-     */
+     * @deprecated in favor of diffCommandProperty
+   * 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
+   * @return {boolean} true if no changes, false otherwise
+   */
     diffCommandFlags(initialFlags: string[], updatedFlags: Change[]): {
         addedFlags: string[];
         removedFlags: string[];
         updatedFlags: Change[];
         changedFlags: Change[];
     };
+    /**
+   * compares two command's properties to each other
+   * @return a list of added, removed, updated, and changed properties
+   * @param initial initial command property to compare against
+   * @param updated generated command property to compare with
+   */
+    diffCommandProperty(initial: string[], updated: Change[]): {
+        addedProperty: string[];
+        removedProperty: string[];
+        updated: Change[];
+        changedProperty: Change[];
+    };
     get changed(): CommandChange[];
     run(): Promise<CompareResponse>;
 }

package/lib/commands/snapshot/compare.js

@@ -23,8 +23,17 @@ class Compare extends snapshot_command_1.SnapshotCommand {
                 return initialCommand.command === updatedCommand.name && samePlugin;
             });
             if (updatedCommand) {
-                const { changedFlags } = this.diffCommandFlags(initialCommand.flags, updatedCommand.flags);
-                if (changedFlags.length > 0) {
+                const changedFlags = this.diffCommandProperty(initialCommand.flags, updatedCommand.flags).changedProperty;
+                const changedAlias = this.diffCommandProperty(initialCommand.alias, updatedCommand.alias).changedProperty;
+                const flagsChanged = changedFlags.length > 0;
+                const aliasChanged = changedAlias.length > 0;
+                if (aliasChanged) {
+                    updatedCommand.alias = changedAlias;
+                }
+                if (flagsChanged) {
+                    updatedCommand.flags = changedFlags;
+                }
+                if (flagsChanged || aliasChanged) {
                     diffCommands.push(updatedCommand);
                 }
             }
@@ -48,52 +57,66 @@ class Compare extends snapshot_command_1.SnapshotCommand {
         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}`));
+        const removedProperties = [];
+        diffCommands.forEach(command => {
+            this.log(`\t${command.name}`);
+            const printCommandDiff = (properties, propertyName) => {
+                if (properties.find(prop => prop.added || prop.removed))
+                    this.log(`\t  ${propertyName}:`);
+                properties.forEach(prop => {
+                    if (prop.added || prop.removed) {
+                        const color = prop.added ? chalk.green : chalk.red;
+                        this.log(color(`\t\t${prop.added ? '+' : '-'}${prop.name}`));
                     }
-                    if (flag.removed)
-                        removedFlags.push();
+                    if (prop.removed)
+                        removedProperties.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) {
+            };
+            printCommandDiff(command.flags, 'Flags');
+            printCommandDiff(command.alias, 'Aliases');
+        });
+        this.log(`${os_1.EOL}Command, flag, or alias differences detected. If intended, please update the snapshot file and run again.`);
+        // Check if existent commands, or properties (flags, aliases) have been deleted
+        if (removedCommands.length > 0 || removedProperties.length > 0) {
             this.log(chalk.red(`${os_1.EOL}Since there are deletions, a major version bump is required.`));
         }
-        return { addedCommands, removedCommands, removedFlags, diffCommands };
+        return { addedCommands, removedCommands, removedFlags: removedCommands, 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
-     */
+     * @deprecated in favor of diffCommandProperty
+   * 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
+   * @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);
+        const diffedFlags = this.diffCommandProperty(initialFlags, updatedFlags);
+        return { addedFlags: diffedFlags.addedProperty, removedFlags: diffedFlags.removedProperty, updatedFlags: diffedFlags.updated, changedFlags: diffedFlags.changedProperty };
+    }
+    /**
+   * compares two command's properties to each other
+   * @return a list of added, removed, updated, and changed properties
+   * @param initial initial command property to compare against
+   * @param updated generated command property to compare with
+   */
+    diffCommandProperty(initial, updated) {
+        const updatedPropertyNames = updated.map(update => update.name);
+        const addedProperty = _.difference(updatedPropertyNames, initial);
+        const removedProperty = _.difference(initial, updatedPropertyNames);
+        const changedProperty = [];
+        updated.forEach(update => {
+            if (addedProperty.includes(update.name)) {
+                update.added = true;
+                changedProperty.push(update);
             }
         });
-        removedFlags.forEach(removedFlag => {
-            changedFlags.push({ name: removedFlag, removed: true });
+        removedProperty.forEach(remove => {
+            changedProperty.push({ name: remove, 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 });
+            updated.push({ name: remove, removed: true });
         });
-        return { addedFlags, removedFlags, updatedFlags, changedFlags };
+        return { addedProperty, removedProperty, updated, changedProperty };
     }
     get changed() {
         return this.commands.map(command => {
@@ -101,14 +124,15 @@ class Compare extends snapshot_command_1.SnapshotCommand {
                 name: command.id,
                 plugin: command.pluginName || '',
                 flags: Object.entries(command.flags).map(flagName => ({ name: flagName[0] })),
+                alias: command.aliases.map(alias => ({ name: alias })),
             };
         });
     }
     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);
+        const oldCommands = JSON.parse(fs.readFileSync(flags.filepath).toString('utf8'));
+        const newCommands = this.changed;
+        return this.compareSnapshot(oldCommands, newCommands);
     }
 }
 exports.default = Compare;

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

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

package/lib/snapshot-command.d.ts

@@ -3,6 +3,7 @@ export declare type SnapshotEntry = {
     command: string;
     plugin: string;
     flags: string[];
+    alias: string[];
 };
 export declare abstract class SnapshotCommand extends Command {
     get commands(): import("@oclif/core/lib/interfaces").Command.Plugin[];

package/lib/snapshot-command.js

@@ -18,6 +18,7 @@ class SnapshotCommand extends core_1.Command {
                 command: command.id,
                 plugin: command.pluginName,
                 flags: Object.keys(command.flags).sort(),
+                alias: command.aliases,
             };
         });
     }

package/oclif.manifest.json

@@ -1 +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":[]}}}
+{"version":"3.1.3","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":[]}}}