bump-cli 2.8.4 → 2.9.1

package/README.md

@@ -1,7 +1,7 @@
 # Bump CLI
 
 <p align="center">
-  <img width="20%" src="https://bump.sh/icon-default-large.png" />
+  <img width="20%" src="https://bump.sh/icon-default-maskable-large.png" />
 </p>
 
 <p align="center">
@@ -32,7 +32,7 @@ Under the hood, it uses the API of [developers.bump.sh](https://developers.bump.
 
 ## Installation
 
-The Bump.sh CLI is a node package currently distributed via NPM. This means you must have the Node v14+ interpreter installed on your computer or CI servers.
+The Bump.sh CLI is a node package currently distributed via NPM. This means you must have the Node v20+ interpreter installed on your computer or CI servers.
 
 _If you are looking to use Bump.sh in a continuous integration environment you might be interested by [our Github Action](https://github.com/marketplace/actions/api-documentation-on-bump)._
 
@@ -257,7 +257,7 @@ Please check `bump preview --help` for more usage details
 
 > This feature implements the [OpenAPI Overlay specification](https://github.com/OAI/Overlay-Specification). It is possible to apply an Overlay to any kind of document, be it an OpenAPI or AsyncAPI definition file.
 
-The Overlay specification of OpenAPI makes it possible to modify the content of an API definition file by adding a layer on top of it. That layer helps add, remove, or change some or all of the content of the original definition. 
+The Overlay specification of OpenAPI makes it possible to modify the content of an API definition file by adding a layer on top of it. That layer helps add, remove, or change some or all of the content of the original definition.
 
 Technically, the `bump overlay` command will output a modified version of the `[DEFINITION_FILE]` (an OpenAPI or AsyncAPI document) by applying the operations described in the `[OVERLAY_FILE]` Overlay file to the original API document.
 
@@ -270,34 +270,34 @@ bump overlay api-document.yaml overlay-file.yaml > api-overlayed-document.yaml
 _Note: you can also apply the overlay during the [`bump deploy` command]((#bump-deploy-file)) with the new `--overlay` flag:_
 
 ```shell
-bump deploy api-document.yaml --doc my-doc --token my-token --overlay overlay-file.yaml 
+bump deploy api-document.yaml --doc my-doc --token my-token --overlay overlay-file.yaml
 ```
 
 ## Development
 
-Make sure to have Node.js (At least v14) installed on your machine.
+Make sure to have Node.js (At least v20) installed on your machine.
 
 - Install node dependencies with
-  
+
   ```sh-session
   npm install
   ```
-  
+
 - Compile the Typescript code
-  
+
   ```sh-session
   npm run build
   npm run clean # to remove build artifacts
   ```
-  
+
 - Format the codebase to comply with the linter rules
-  
+
   ```sh-session
   npm run fmt
   ```
-  
+
 - Run the test suites
-  
+
   ```sh-session
   npm run test
   npm run test-coverage # Run tests with coverage

package/bin/dev.cmd

@@ -0,0 +1,3 @@
+@echo off
+
+node --loader ts-node/esm --no-warnings=ExperimentalWarning "%~dp0\dev" %*

package/bin/dev.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env -S node --loader ts-node/esm --disable-warning=ExperimentalWarning
+
+// eslint-disable-next-line n/shebang
+import {execute} from '@oclif/core'
+
+await execute({development: true, dir: import.meta.url})

package/bin/run.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+import {execute} from '@oclif/core'
+
+await execute({dir: import.meta.url})

package/{lib → dist}/api/error.d.ts

@@ -1,16 +1,13 @@
-import { CLIError } from '@oclif/errors';
+import { CLIError } from '@oclif/core/errors';
 import { AxiosError } from 'axios';
-import { InvalidDefinitionError } from './models';
-declare type MessagesAndExitCode = [string[], number];
+import { InvalidDefinitionError } from './models.js';
+type MessagesAndExitCode = [string[], number];
 export default class APIError extends CLIError {
-    http: AxiosError;
-    exitCode: number;
-    status?: number;
-    constructor(httpError: AxiosError, info?: string[], exit?: number);
+    constructor(httpError?: AxiosError | undefined, info?: string[], exit?: number);
+    static humanAttributeError(attribute: string, messages: unknown): string[];
+    static invalidDefinition(error: InvalidDefinitionError): MessagesAndExitCode;
     static is(error: Error): error is APIError;
     static notFound(error: Error): MessagesAndExitCode;
-    static invalidDefinition(error: InvalidDefinitionError): MessagesAndExitCode;
-    static humanAttributeError(attribute: string, messages: unknown): string[];
     static unauthenticated(): MessagesAndExitCode;
 }
 export {};

package/dist/api/error.js

@@ -0,0 +1,97 @@
+import { CLIError } from '@oclif/core/errors';
+import chalk from 'chalk';
+import d from 'debug';
+const debug = d('bump-cli:api-client');
+export default class APIError extends CLIError {
+    constructor(httpError, info = [], exit = 100) {
+        const status = httpError?.response?.status;
+        debug(httpError);
+        if (httpError) {
+            switch (status) {
+                case 422: {
+                    ;
+                    [info, exit] = APIError.invalidDefinition(httpError.response?.data);
+                    break;
+                }
+                case 401: {
+                    ;
+                    [info, exit] = APIError.unauthenticated();
+                    break;
+                }
+                case 404:
+                case 400: {
+                    ;
+                    [info, exit] = APIError.notFound(httpError.response?.data);
+                    break;
+                }
+            }
+            if (info.length > 0) {
+                super(info.join('\n'), { exit });
+            }
+            else {
+                super(`Unhandled API error (status: ${status}) (error: ${httpError})`, { exit });
+            }
+        }
+        else {
+            super('Unhandled API error', { exit });
+        }
+    }
+    static humanAttributeError(attribute, messages) {
+        let info = [];
+        if (Array.isArray(messages)) {
+            const allMessages = messages
+                .map((message, idx) => {
+                if (message instanceof Object) {
+                    return this.humanAttributeError(idx.toString(), message);
+                }
+                return message;
+            })
+                .join(', ');
+            info.push(`${chalk.underline(attribute)} ${allMessages}`);
+        }
+        else if (messages instanceof Object) {
+            for (const [child, childMessages] of Object.entries(messages)) {
+                const childErrors = this.humanAttributeError(`${attribute}.${child}`, childMessages);
+                info = [...info, ...childErrors];
+            }
+        }
+        else if (messages) {
+            info.push(`${chalk.underline(attribute)} ${messages}`);
+        }
+        return info;
+    }
+    static invalidDefinition(error) {
+        let info = [];
+        const genericMessage = error.message || 'Invalid definition file';
+        const exit = 122;
+        if (error && 'errors' in error) {
+            for (const [attr, message] of Object.entries(error.errors)) {
+                const humanErrors = APIError.humanAttributeError(attr, message);
+                info = [...info, ...humanErrors];
+            }
+        }
+        else {
+            info.push(genericMessage);
+        }
+        return [info, exit];
+    }
+    static is(error) {
+        return error instanceof CLIError && 'http' in error;
+    }
+    static notFound(error) {
+        const genericMessage = error.message || "It seems the documentation provided doesn't exist.";
+        return [
+            [
+                genericMessage,
+                `In a hub context you might want to try the ${chalk.dim('--auto-create')} flag.\nOtherwise, please check the given ${chalk.dim('--doc')}, ${chalk.dim('--token')} or ${chalk.dim('--hub')} flags`,
+            ],
+            104,
+        ];
+    }
+    static unauthenticated() {
+        return [
+            ['You are not allowed to deploy to this documentation.', 'please check your --token flag or BUMP_TOKEN variable'],
+            101,
+        ];
+    }
+}

package/{lib → dist}/api/index.d.ts

@@ -1,22 +1,22 @@
-import * as Config from '@oclif/config';
+import { Config } from '@oclif/core';
 import { AxiosInstance, AxiosResponse } from 'axios';
-import { PingResponse, PreviewRequest, PreviewResponse, VersionRequest, VersionResponse, DiffRequest, DiffResponse, WithDiff } from './models';
-import APIError from './error';
+import { DiffRequest, DiffResponse, PingResponse, PreviewRequest, PreviewResponse, VersionRequest, VersionResponse, WithDiff } from './models.js';
 declare class BumpApi {
-    protected config: Config.IConfig;
+    protected config: Config;
     protected readonly client: AxiosInstance;
-    constructor(config: Config.IConfig);
+    getDiff: (diffId: string, format: string) => Promise<AxiosResponse<DiffResponse>>;
     getPing: () => Promise<AxiosResponse<PingResponse>>;
     getVersion: (versionId: string, token: string) => Promise<AxiosResponse<VersionResponse & WithDiff>>;
-    postPreview: (body?: PreviewRequest | undefined) => Promise<AxiosResponse<PreviewResponse>>;
-    putPreview: (versionId: string, body?: PreviewRequest | undefined) => Promise<AxiosResponse<PreviewResponse>>;
-    postVersion: (body: VersionRequest, token: string) => Promise<AxiosResponse<VersionResponse>>;
     postDiff: (body: DiffRequest) => Promise<AxiosResponse<DiffResponse>>;
-    getDiff: (diffId: string, format: string) => Promise<AxiosResponse<DiffResponse>>;
+    postPreview: (body?: PreviewRequest) => Promise<AxiosResponse<PreviewResponse>>;
     postValidation: (body: VersionRequest, token: string) => Promise<AxiosResponse<void>>;
-    private initializeResponseInterceptor;
-    private handleError;
+    postVersion: (body: VersionRequest, token: string) => Promise<AxiosResponse<VersionResponse>>;
+    putPreview: (versionId: string, body?: PreviewRequest) => Promise<AxiosResponse<PreviewResponse>>;
     private authorizationHeader;
+    private handleError;
+    private initializeResponseInterceptor;
+    constructor(config: Config);
 }
-export * from './models';
-export { BumpApi, APIError };
+export { default as APIError } from './error.js';
+export { BumpApi };
+export * from './models.js';

package/dist/api/index.js

@@ -0,0 +1,46 @@
+import axios from 'axios';
+import APIError from './error.js';
+import { vars } from './vars.js';
+class BumpApi {
+    config;
+    client;
+    getDiff = (diffId, format) => this.client.get(`/diffs/${diffId}`, {
+        params: { formats: [format] },
+    });
+    getPing = () => this.client.get('/ping');
+    getVersion = (versionId, token) => this.client.get(`/versions/${versionId}`, {
+        headers: this.authorizationHeader(token),
+    });
+    postDiff = (body) => this.client.post('/diffs', body);
+    postPreview = (body) => this.client.post('/previews', body);
+    postValidation = (body, token) => this.client.post('/validations', body, {
+        headers: this.authorizationHeader(token),
+    });
+    postVersion = (body, token) => this.client.post('/versions', body, {
+        headers: this.authorizationHeader(token),
+    });
+    putPreview = (versionId, body) => this.client.put(`/previews/${versionId}`, body);
+    authorizationHeader = (token) => ({
+        Authorization: `Basic ${Buffer.from(token).toString('base64')}`,
+    });
+    handleError = (error) => Promise.reject(new APIError(error));
+    initializeResponseInterceptor = () => {
+        this.client.interceptors.response.use((data) => data, this.handleError);
+    };
+    // Check https://oclif.io/docs/config for details about Config.IConfig
+    constructor(config) {
+        this.config = config;
+        const baseURL = `${vars.apiUrl}${vars.apiBasePath}`;
+        const headers = {
+            'User-Agent': vars.apiUserAgent(config.userAgent),
+        };
+        this.client = axios.create({
+            baseURL,
+            headers,
+        });
+        this.initializeResponseInterceptor();
+    }
+}
+export { default as APIError } from './error.js';
+export { BumpApi };
+export * from './models.js';

package/dist/api/models.js

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

package/{lib → dist}/api/vars.js

@@ -1,23 +1,19 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.vars = exports.Vars = void 0;
-class Vars {
-    get host() {
-        return this.envHost || 'bump.sh';
+export class Vars {
+    get apiBasePath() {
+        return '/api/v1';
+    }
+    get apiUrl() {
+        return this.host.startsWith('http') ? this.host : `https://${this.host}`;
     }
     get envHost() {
         return process.env.BUMP_HOST;
     }
+    get host() {
+        return this.envHost || 'bump.sh';
+    }
     apiUserAgent(base) {
         const content = [base, process.env.BUMP_USER_AGENT].filter(Boolean);
         return content.join(' ');
     }
-    get apiUrl() {
-        return this.host.startsWith('http') ? this.host : `https://${this.host}`;
-    }
-    get apiBasePath() {
-        return '/api/v1';
-    }
 }
-exports.Vars = Vars;
-exports.vars = new Vars();
+export const vars = new Vars();

package/dist/args.d.ts

@@ -0,0 +1,4 @@
+declare const fileArg: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+declare const otherFileArg: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+declare const overlayFileArg: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+export { fileArg, otherFileArg, overlayFileArg };

package/{lib → dist}/args.js

@@ -1,20 +1,16 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.overlayFileArg = exports.otherFileArg = exports.fileArg = void 0;
-const fileArg = {
+import { Args } from '@oclif/core';
+const fileArg = Args.string({
+    description: 'Path or URL to your API documentation file. OpenAPI (2.0 to 3.1.0) and AsyncAPI (2.x) specifications are currently supported.\nPath can also be a directory when deploying to a Hub.',
     name: 'FILE',
     required: true,
-    description: 'Path or URL to your API documentation file. OpenAPI (2.0 to 3.1.0) and AsyncAPI (2.x) specifications are currently supported.\nPath can also be a directory when deploying to a Hub.',
-};
-exports.fileArg = fileArg;
-const otherFileArg = {
-    name: 'FILE2',
+});
+const otherFileArg = Args.string({
     description: 'Path or URL to a second API documentation file to compute its diff',
-};
-exports.otherFileArg = otherFileArg;
-const overlayFileArg = {
+    name: 'FILE2',
+});
+const overlayFileArg = Args.string({
+    description: 'Path or URL to an overlay file',
     name: 'OVERLAY_FILE',
     required: true,
-    description: 'Path or URL to an overlay file',
-};
-exports.overlayFileArg = overlayFileArg;
+});
+export { fileArg, otherFileArg, overlayFileArg };

package/dist/base-command.d.ts

@@ -0,0 +1,7 @@
+import { Command } from '@oclif/core';
+import { BumpApi } from './api/index.js';
+export declare abstract class BaseCommand<T extends typeof Command> extends Command {
+    protected _bump: BumpApi;
+    protected get bump(): BumpApi;
+    protected d(formatter: any, ...args: any[]): void;
+}

package/dist/base-command.js

@@ -0,0 +1,18 @@
+import { Command } from '@oclif/core';
+import debug from 'debug';
+import { BumpApi } from './api/index.js';
+/* eslint-disable-next-line @typescript-eslint/no-unused-vars */
+export class BaseCommand extends Command {
+    _bump;
+    get bump() {
+        if (!this._bump)
+            this._bump = new BumpApi(this.config);
+        return this._bump;
+    }
+    // Function signature type taken from @types/debug
+    // Debugger(formatter: any, ...args: any[]): void;
+    /* eslint-disable-next-line @typescript-eslint/no-explicit-any */
+    d(formatter, ...args) {
+        return debug(`bump-cli:command:${this.constructor.name.toLowerCase()}`)(formatter, ...args);
+    }
+}

package/dist/commands/deploy.d.ts

@@ -0,0 +1,24 @@
+import { BaseCommand } from '../base-command.js';
+import { API } from '../definition.js';
+export default class Deploy extends BaseCommand<typeof Deploy> {
+    static args: {
+        file: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        'auto-create': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        branch: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        doc: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        'doc-name': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'filename-pattern': import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        hub: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        interactive: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        overlay: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        token: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    protected deployDirectory(dir: string, dryRun: boolean, token: string, hub: string, autoCreate: boolean, interactive: boolean, filenamePattern: string, documentationName: string | undefined, branch: string | undefined): Promise<void>;
+    protected deploySingleFile(api: API, dryRun: boolean, documentation: string, token: string, hub: string | undefined, autoCreate: boolean, documentationName: string | undefined, branch: string | undefined, overlay?: string | undefined): Promise<void>;
+    run(): Promise<void>;
+}

package/dist/commands/deploy.js

@@ -0,0 +1,158 @@
+import { ux } from '@oclif/core';
+import { CLIError } from '@oclif/core/errors';
+import chalk from 'chalk';
+import { fileArg } from '../args.js';
+import { BaseCommand } from '../base-command.js';
+import { DefinitionDirectory } from '../core/definition-directory.js';
+import { Deploy as CoreDeploy } from '../core/deploy.js';
+import { isDir } from '../core/utils/file.js';
+import { confirm as promptConfirm } from '../core/utils/prompts.js';
+import { API } from '../definition.js';
+import * as flagsBuilder from '../flags.js';
+export default class Deploy extends BaseCommand {
+    static args = { file: fileArg };
+    static description = 'Create a new version of your documentation from the given file or URL.';
+    static examples = [
+        `Deploy a new version of ${chalk.underline('an existing documentation')}
+
+${chalk.dim('$ bump deploy FILE --doc <your_doc_id_or_slug> --token <your_doc_token>')}
+* Let's deploy on Bump.sh... done
+* Your new documentation version will soon be ready
+`,
+        `Deploy a new version of ${chalk.underline('an existing documentation attached to a hub')}
+
+${chalk.dim('$ bump deploy FILE --doc <doc_slug> --hub <your_hub_id_or_slug> --token <your_doc_token>')}
+* Let's deploy on Bump.sh... done
+* Your new documentation version will soon be ready
+`,
+        `Deploy a whole directory of ${chalk.underline('API definitions files to a hub')}
+
+${chalk.dim('$ bump deploy DIR --filename-pattern *-{slug}-api --hub <hub_slug> --token <hub_token>')}
+We've found 2 valid API definitions to deploy
+└─ DIR
+   └─ source-my-service-api.yml (OpenAPI spec version 3.1.0)
+   └─ source-my-jobs-service-api.yml (AsyncAPI spec version 2.6.0)
+
+Let's deploy those documentations to your <hub_slug> hub on Bump.sh
+
+* Your new documentation version will soon be ready
+Let's deploy a new version to your my-service documentation on Bump.sh... done
+
+* Your new documentation version will soon be ready
+Let's deploy a new version to your my-jobs-service documentation on Bump.sh... done
+`,
+        `${chalk.underline('Validate a new documentation version')} before deploying it
+
+${chalk.dim('$ bump deploy FILE --dry-run --doc <doc_slug> --token <your_doc_token>')}
+* Let's validate on Bump.sh... done
+* Definition is valid
+`,
+    ];
+    static flags = {
+        'auto-create': flagsBuilder.autoCreate(),
+        branch: flagsBuilder.branch(),
+        doc: flagsBuilder.doc(),
+        'doc-name': flagsBuilder.docName(),
+        'dry-run': flagsBuilder.dryRun(),
+        'filename-pattern': flagsBuilder.filenamePattern(),
+        hub: flagsBuilder.hub(),
+        interactive: flagsBuilder.interactive(),
+        overlay: flagsBuilder.overlay(),
+        token: flagsBuilder.token(),
+    };
+    async deployDirectory(dir, dryRun, token, hub, autoCreate, interactive, filenamePattern, documentationName, branch) {
+        const definitionDirectory = new DefinitionDirectory(dir, filenamePattern);
+        await definitionDirectory.readDefinitions();
+        await ux.action.pauseAsync(async () => {
+            definitionDirectory.stdoutDefinitions();
+            // In “interactive” mode we ask the user if he wants to add more
+            // definitions to deploy. He is thus presented a form to select
+            // some files from the target directory.
+            if (interactive) {
+                let confirm = true;
+                if (definitionDirectory.definitionsExists()) {
+                    confirm = await promptConfirm('Do you want to add more files to deploy?');
+                }
+                if (confirm) {
+                    await ux.action.pauseAsync(async () => {
+                        await definitionDirectory.interactiveSelection();
+                    });
+                }
+            }
+        });
+        if (definitionDirectory.definitionsExists()) {
+            await ux.action.pauseAsync(async () => {
+                definitionDirectory.stdoutDefinitions();
+                if (interactive) {
+                    await definitionDirectory.sequentialMap(async (definition) => {
+                        await definitionDirectory.renameToConvention(definition);
+                    });
+                }
+            });
+            ux.action.status = `...to your ${hub} hub on Bump.sh`;
+            await definitionDirectory.sequentialMap(async (definition) => {
+                await this.deploySingleFile(definition.definition, dryRun, definition.slug, token, hub, autoCreate, definition.slug || documentationName, branch);
+            });
+        }
+        else {
+            throw new CLIError(`No documentation found in ${dir} with the pattern '${filenamePattern}'.\nYou should check with the ${chalk.dim('--filename-pattern')} flag to select your files from your naming convention.\nIf you don't have a naming convention we can help naming your API definition files:\nTry the ${chalk.dim('--interactive')} flag for that.`);
+        }
+    }
+    async deploySingleFile(api, dryRun, documentation, token, hub, autoCreate, documentationName, branch, overlay) {
+        ux.action.status = `...a new version to your ${documentation} documentation`;
+        const response = await new CoreDeploy(this.bump).run(api, dryRun, documentation, token, hub, autoCreate, documentationName, branch, overlay);
+        if (dryRun) {
+            ux.stdout(ux.colorize('green', 'Definition is valid'));
+        }
+        else if (response) {
+            process.stdout.write(ux.colorize('green', `Your ${documentation} documentation...`));
+            ux.stdout(ux.colorize('green', `has received a new deployment which will soon be ready at:`));
+            ux.stdout(ux.colorize('underline', response.doc_public_url));
+        }
+        else {
+            ux.warn(`Your ${documentation} documentation has not changed`);
+        }
+    }
+    /*
+      Oclif doesn't type parsed args & flags correctly and especially
+      required-ness which is not known by the compiler, thus the use of
+      the non-null assertion '!' in this command.
+      See https://github.com/oclif/oclif/issues/301 for details
+    */
+    async run() {
+        const { args, flags } = await this.parse(Deploy);
+        const [dryRun, documentation, token, hub, autoCreate, interactive, filenamePattern, documentationName, branch, overlay,] = [
+            flags['dry-run'],
+            flags.doc,
+            flags.token,
+            flags.hub,
+            flags['auto-create'],
+            flags.interactive,
+            /* Flags.filenamePattern has a default value, so it's always defined. But
+             * oclif types doesn't detect it */
+            flags['filename-pattern'],
+            flags['doc-name'],
+            flags.branch,
+            flags.overlay,
+        ];
+        const action = dryRun ? 'validate' : 'deploy';
+        ux.action.start(`Let's ${action} on Bump.sh`);
+        if (isDir(args.file)) {
+            if (hub) {
+                await this.deployDirectory(args.file, dryRun, token, hub, autoCreate, interactive, filenamePattern, documentationName, branch);
+            }
+            else {
+                throw new CLIError('Missing required flag --hub when deploying an entire directory');
+            }
+        }
+        else if (documentation) {
+            const api = await API.load(args.file);
+            this.d(`${args.file} looks like an ${api.specName} spec version ${api.version}`);
+            await this.deploySingleFile(api, dryRun, documentation, token, hub, autoCreate, documentationName, branch, overlay);
+        }
+        else {
+            throw new CLIError('Missing required flag --doc=<slug>');
+        }
+        ux.action.stop();
+    }
+}

package/dist/commands/diff.d.ts

@@ -0,0 +1,21 @@
+import { DiffResponse } from '../api/models.js';
+import { BaseCommand } from '../base-command.js';
+export default class Diff extends BaseCommand<typeof Diff> {
+    static args: {
+        file: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+        otherFile: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        branch: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        doc: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        expires: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'fail-on-breaking': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        format: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        hub: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        token: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    displayCompareResult(result: DiffResponse, format: string, failOnBreaking: boolean): Promise<void>;
+    run(): Promise<void>;
+}