nx 20.0.0-beta.5 → 20.0.0-beta.7

package/release/changelog-renderer/index.js

@@ -6,182 +6,239 @@ const github_1 = require("../../src/command-line/release/utils/github");
 // axios types and values don't seem to match
 const _axios = require("axios");
 const axios = _axios;
-/**
- * The default ChangelogRenderer implementation that nx exports for the common case of generating markdown
- * from the given commits and other metadata.
- */
-const defaultChangelogRenderer = async ({ projectGraph, changes, releaseVersion, project, entryWhenNoChanges, changelogRenderOptions, dependencyBumps, repoSlug, conventionalCommitsConfig, repoData, }) => {
-    const markdownLines = [];
-    // If the current range of changes contains both a commit and its revert, we strip them both from the final list. Changes from version plans are unaffected, as they have no hashes.
-    for (const change of changes) {
-        if (change.type === 'revert' && change.revertedHashes) {
-            for (const revertedHash of change.revertedHashes) {
-                const revertedCommit = changes.find((c) => c.shortHash && revertedHash.startsWith(c.shortHash));
-                if (revertedCommit) {
-                    changes.splice(changes.indexOf(revertedCommit), 1);
-                    changes.splice(changes.indexOf(change), 1);
-                }
-            }
+class DefaultChangelogRenderer {
+    /**
+     * A ChangelogRenderer class takes in the determined changes and other relevant metadata
+     * and returns a string, or a Promise of a string of changelog contents (usually markdown).
+     *
+     * @param {Object} config The configuration object for the ChangelogRenderer
+     * @param {ChangelogChange[]} config.changes The collection of changes to show in the changelog
+     * @param {string} config.changelogEntryVersion The version for which we are rendering the current changelog entry
+     * @param {string | null} config.project The name of specific project to generate a changelog entry for, or `null` if the overall workspace changelog
+     * @param {string | false} config.entryWhenNoChanges The (already interpolated) string to use as the changelog entry when there are no changes, or `false` if no entry should be generated
+     * @param {boolean} config.isVersionPlans Whether or not Nx release version plans are the source of truth for the changelog entry
+     * @param {ChangelogRenderOptions} config.changelogRenderOptions The options specific to the ChangelogRenderer implementation
+     * @param {DependencyBump[]} config.dependencyBumps Optional list of additional dependency bumps that occurred as part of the release, outside of the change data
+     * @param {GithubRepoData} config.repoData Resolved data for the current GitHub repository
+     * @param {NxReleaseConfig['conventionalCommits'] | null} config.conventionalCommitsConfig The configuration for conventional commits, or null if version plans are being used
+     */
+    constructor(config) {
+        this.changes = this.filterChanges(config.changes, config.project);
+        this.changelogEntryVersion = config.changelogEntryVersion;
+        this.project = config.project;
+        this.entryWhenNoChanges = config.entryWhenNoChanges;
+        this.isVersionPlans = config.isVersionPlans;
+        this.changelogRenderOptions = config.changelogRenderOptions;
+        this.dependencyBumps = config.dependencyBumps;
+        this.repoData = config.repoData;
+        this.conventionalCommitsConfig = config.conventionalCommitsConfig;
+        this.relevantChanges = [];
+        this.breakingChanges = [];
+        this.additionalChangesForAuthorsSection = [];
+    }
+    filterChanges(changes, project) {
+        if (project === null) {
+            return changes;
         }
+        return changes.filter((c) => c.affectedProjects &&
+            (c.affectedProjects === '*' || c.affectedProjects.includes(project)));
     }
-    let relevantChanges = changes;
-    const breakingChanges = [];
-    // For now to keep the interface of the changelog renderer non-breaking for v19 releases we have a somewhat indirect check for whether or not we are generating a changelog for version plans
-    const isVersionPlans = !conventionalCommitsConfig;
-    // Only applicable for version plans
-    const additionalChangesForAuthorsSection = [];
-    // Provide a default configuration for version plans to allow most of the subsequent logic to work in the same way it would for conventional commits
-    // NOTE: The one exception is breaking/major changes, where we do not follow the same structure and instead only show the changes once
-    if (isVersionPlans) {
-        conventionalCommitsConfig = {
-            types: {
-                feat: conventional_commits_1.DEFAULT_CONVENTIONAL_COMMITS_CONFIG.types.feat,
-                fix: conventional_commits_1.DEFAULT_CONVENTIONAL_COMMITS_CONFIG.types.fix,
-            },
-        };
-        // Trim down "relevant changes" to only include non-breaking ones so that we can render them differently under version plans,
-        // but keep track of the changes for the purposes of the authors section
-        // TODO(v20): Clean this abstraction up as part of the larger overall refactor of changelog rendering
-        for (let i = 0; i < relevantChanges.length; i++) {
-            if (relevantChanges[i].isBreaking) {
-                const change = relevantChanges[i];
-                additionalChangesForAuthorsSection.push(change);
-                const line = formatChange(change, changelogRenderOptions, isVersionPlans, repoData);
-                breakingChanges.push(line);
-                relevantChanges.splice(i, 1);
-            }
+    async render() {
+        const sections = [];
+        this.preprocessChanges();
+        if (this.shouldRenderEmptyEntry()) {
+            return this.renderEmptyEntry();
+        }
+        sections.push([this.renderVersionTitle()]);
+        const changesByType = this.renderChangesByType();
+        if (changesByType.length > 0) {
+            sections.push(changesByType);
+        }
+        if (this.hasBreakingChanges()) {
+            sections.push(this.renderBreakingChanges());
+        }
+        if (this.hasDependencyBumps()) {
+            sections.push(this.renderDependencyBumps());
         }
+        if (this.shouldRenderAuthors()) {
+            sections.push(await this.renderAuthors());
+        }
+        // Join sections with double newlines, and trim any extra whitespace
+        return sections
+            .filter((section) => section.length > 0)
+            .map((section) => section.join('\n').trim())
+            .join('\n\n')
+            .trim();
     }
-    const changeTypes = conventionalCommitsConfig.types;
-    // workspace root level changelog
-    if (project === null) {
-        // No changes for the workspace
-        if (relevantChanges.length === 0 && breakingChanges.length === 0) {
-            if (dependencyBumps?.length) {
-                applyAdditionalDependencyBumps({
-                    markdownLines,
-                    dependencyBumps,
-                    releaseVersion,
-                    changelogRenderOptions,
-                });
-            }
-            else if (entryWhenNoChanges) {
-                markdownLines.push('', `${createVersionTitle(releaseVersion, changelogRenderOptions)}\n\n${entryWhenNoChanges}`, '');
+    preprocessChanges() {
+        this.relevantChanges = [...this.changes];
+        this.breakingChanges = [];
+        this.additionalChangesForAuthorsSection = [];
+        // Filter out reverted changes
+        for (let i = this.relevantChanges.length - 1; i >= 0; i--) {
+            const change = this.relevantChanges[i];
+            if (change.type === 'revert' && change.revertedHashes) {
+                for (const revertedHash of change.revertedHashes) {
+                    const revertedCommitIndex = this.relevantChanges.findIndex((c) => c.shortHash && revertedHash.startsWith(c.shortHash));
+                    if (revertedCommitIndex !== -1) {
+                        this.relevantChanges.splice(revertedCommitIndex, 1);
+                        this.relevantChanges.splice(i, 1);
+                        i--;
+                        break;
+                    }
+                }
             }
-            return markdownLines.join('\n').trim();
         }
-        const typeGroups = groupBy(relevantChanges, 'type');
-        markdownLines.push('', createVersionTitle(releaseVersion, changelogRenderOptions), '');
-        for (const type of Object.keys(changeTypes)) {
-            const group = typeGroups[type];
-            if (!group || group.length === 0) {
-                continue;
+        if (this.isVersionPlans) {
+            this.conventionalCommitsConfig = {
+                types: {
+                    feat: conventional_commits_1.DEFAULT_CONVENTIONAL_COMMITS_CONFIG.types.feat,
+                    fix: conventional_commits_1.DEFAULT_CONVENTIONAL_COMMITS_CONFIG.types.fix,
+                },
+            };
+            for (let i = this.relevantChanges.length - 1; i >= 0; i--) {
+                if (this.relevantChanges[i].isBreaking) {
+                    const change = this.relevantChanges[i];
+                    this.additionalChangesForAuthorsSection.push(change);
+                    const line = this.formatChange(change);
+                    this.breakingChanges.push(line);
+                    this.relevantChanges.splice(i, 1);
+                }
             }
-            markdownLines.push('', '### ' + changeTypes[type].changelog.title, '');
-            /**
-             * In order to make the final changelog most readable, we organize changes as follows:
-             * - By scope, where scopes are in alphabetical order (changes with no scope are listed first)
-             * - Within a particular scope grouping, we list changes in chronological order
-             */
-            const changesInChronologicalOrder = group.reverse();
-            const changesGroupedByScope = groupBy(changesInChronologicalOrder, 'scope');
-            const scopesSortedAlphabetically = Object.keys(changesGroupedByScope).sort();
-            for (const scope of scopesSortedAlphabetically) {
-                const changes = changesGroupedByScope[scope];
-                for (const change of changes) {
-                    const line = formatChange(change, changelogRenderOptions, isVersionPlans, repoData);
-                    markdownLines.push(line);
-                    if (change.isBreaking) {
-                        const breakingChangeExplanation = extractBreakingChangeExplanation(change.body);
-                        breakingChanges.push(breakingChangeExplanation
-                            ? `- ${change.scope ? `**${change.scope.trim()}:** ` : ''}${breakingChangeExplanation}`
-                            : line);
-                    }
+        }
+        else {
+            for (const change of this.relevantChanges) {
+                if (change.isBreaking) {
+                    const breakingChangeExplanation = this.extractBreakingChangeExplanation(change.body);
+                    this.breakingChanges.push(breakingChangeExplanation
+                        ? `- ${change.scope ? `**${change.scope.trim()}:** ` : ''}${breakingChangeExplanation}`
+                        : this.formatChange(change));
                 }
             }
         }
     }
-    else {
-        // project level changelog
-        relevantChanges = relevantChanges.filter((c) => c.affectedProjects &&
-            (c.affectedProjects === '*' || c.affectedProjects.includes(project)));
-        // Generating for a named project, but that project has no relevant changes in the current set of commits, exit early
-        if (relevantChanges.length === 0 && breakingChanges.length === 0) {
-            if (dependencyBumps?.length) {
-                applyAdditionalDependencyBumps({
-                    markdownLines,
-                    dependencyBumps,
-                    releaseVersion,
-                    changelogRenderOptions,
-                });
-            }
-            else if (entryWhenNoChanges) {
-                markdownLines.push('', `${createVersionTitle(releaseVersion, changelogRenderOptions)}\n\n${entryWhenNoChanges}`, '');
-            }
-            return markdownLines.join('\n').trim();
+    shouldRenderEmptyEntry() {
+        return (this.relevantChanges.length === 0 &&
+            this.breakingChanges.length === 0 &&
+            !this.hasDependencyBumps());
+    }
+    renderEmptyEntry() {
+        if (this.hasDependencyBumps()) {
+            return [
+                this.renderVersionTitle(),
+                '',
+                ...this.renderDependencyBumps(),
+            ].join('\n');
+        }
+        else if (this.entryWhenNoChanges) {
+            return `${this.renderVersionTitle()}\n\n${this.entryWhenNoChanges}`;
         }
-        markdownLines.push('', createVersionTitle(releaseVersion, changelogRenderOptions), '');
-        const typeGroups = groupBy(
-        // Sort the relevant changes to have the unscoped changes first, before grouping by type
-        relevantChanges.sort((a, b) => (b.scope ? 1 : 0) - (a.scope ? 1 : 0)), 'type');
+        return '';
+    }
+    renderVersionTitle() {
+        const isMajorVersion = `${(0, semver_1.major)(this.changelogEntryVersion)}.0.0` ===
+            this.changelogEntryVersion.replace(/^v/, '');
+        let maybeDateStr = '';
+        if (this.changelogRenderOptions.versionTitleDate) {
+            const dateStr = new Date().toISOString().slice(0, 10);
+            maybeDateStr = ` (${dateStr})`;
+        }
+        return isMajorVersion
+            ? `# ${this.changelogEntryVersion}${maybeDateStr}`
+            : `## ${this.changelogEntryVersion}${maybeDateStr}`;
+    }
+    renderChangesByType() {
+        const markdownLines = [];
+        const typeGroups = this.groupChangesByType();
+        const changeTypes = this.conventionalCommitsConfig.types;
         for (const type of Object.keys(changeTypes)) {
             const group = typeGroups[type];
             if (!group || group.length === 0) {
                 continue;
             }
             markdownLines.push('', `### ${changeTypes[type].changelog.title}`, '');
-            const changesInChronologicalOrder = group.reverse();
-            for (const change of changesInChronologicalOrder) {
-                const line = formatChange(change, changelogRenderOptions, isVersionPlans, repoData);
-                markdownLines.push(line + '\n');
-                if (change.isBreaking) {
-                    const breakingChangeExplanation = extractBreakingChangeExplanation(change.body);
-                    breakingChanges.push(breakingChangeExplanation
-                        ? `- ${change.scope ? `**${change.scope.trim()}:** ` : ''}${breakingChangeExplanation}`
-                        : line);
+            if (this.project === null) {
+                const changesGroupedByScope = this.groupChangesByScope(group);
+                const scopesSortedAlphabetically = Object.keys(changesGroupedByScope).sort();
+                for (const scope of scopesSortedAlphabetically) {
+                    const changes = changesGroupedByScope[scope];
+                    for (const change of changes.reverse()) {
+                        const line = this.formatChange(change);
+                        markdownLines.push(line);
+                        if (change.isBreaking && !this.isVersionPlans) {
+                            const breakingChangeExplanation = this.extractBreakingChangeExplanation(change.body);
+                            this.breakingChanges.push(breakingChangeExplanation
+                                ? `- ${change.scope ? `**${change.scope.trim()}:** ` : ''}${breakingChangeExplanation}`
+                                : line);
+                        }
+                    }
+                }
+            }
+            else {
+                // For project-specific changelogs, maintain the original order
+                for (const change of group) {
+                    const line = this.formatChange(change);
+                    markdownLines.push(line);
+                    if (change.isBreaking && !this.isVersionPlans) {
+                        const breakingChangeExplanation = this.extractBreakingChangeExplanation(change.body);
+                        this.breakingChanges.push(breakingChangeExplanation
+                            ? `- ${change.scope ? `**${change.scope.trim()}:** ` : ''}${breakingChangeExplanation}`
+                            : line);
+                    }
                 }
             }
         }
+        return markdownLines;
+    }
+    hasBreakingChanges() {
+        return this.breakingChanges.length > 0;
     }
-    if (breakingChanges.length > 0) {
-        markdownLines.push('', '### ⚠️  Breaking Changes', '', ...breakingChanges);
+    renderBreakingChanges() {
+        const uniqueBreakingChanges = Array.from(new Set(this.breakingChanges));
+        return ['### ⚠️  Breaking Changes', '', ...uniqueBreakingChanges];
     }
-    if (dependencyBumps?.length) {
-        applyAdditionalDependencyBumps({
-            markdownLines,
-            dependencyBumps,
-            releaseVersion,
-            changelogRenderOptions,
+    hasDependencyBumps() {
+        return this.dependencyBumps && this.dependencyBumps.length > 0;
+    }
+    renderDependencyBumps() {
+        const markdownLines = ['', '### 🧱 Updated Dependencies', ''];
+        this.dependencyBumps.forEach(({ dependencyName, newVersion }) => {
+            markdownLines.push(`- Updated ${dependencyName} to ${newVersion}`);
         });
+        return markdownLines;
+    }
+    shouldRenderAuthors() {
+        return this.changelogRenderOptions.authors;
     }
-    if (changelogRenderOptions.authors) {
+    async renderAuthors() {
+        const markdownLines = [];
         const _authors = new Map();
         for (const change of [
-            ...relevantChanges,
-            ...additionalChangesForAuthorsSection,
+            ...this.relevantChanges,
+            ...this.additionalChangesForAuthorsSection,
         ]) {
-            if (!change.author) {
+            if (!change.authors) {
                 continue;
             }
-            const name = formatName(change.author.name);
-            if (!name || name.includes('[bot]')) {
-                continue;
-            }
-            if (_authors.has(name)) {
-                const entry = _authors.get(name);
-                entry.email.add(change.author.email);
-            }
-            else {
-                _authors.set(name, { email: new Set([change.author.email]) });
+            for (const author of change.authors) {
+                const name = this.formatName(author.name);
+                if (!name || name.includes('[bot]')) {
+                    continue;
+                }
+                if (_authors.has(name)) {
+                    const entry = _authors.get(name);
+                    entry.email.add(author.email);
+                }
+                else {
+                    _authors.set(name, { email: new Set([author.email]) });
+                }
             }
         }
-        // Try to map authors to github usernames
-        if (repoData && changelogRenderOptions.mapAuthorsToGitHubUsernames) {
+        if (this.repoData &&
+            this.changelogRenderOptions.mapAuthorsToGitHubUsernames) {
             await Promise.all([..._authors.keys()].map(async (authorName) => {
                 const meta = _authors.get(authorName);
                 for (const email of meta.email) {
-                    // For these pseudo-anonymized emails we can just extract the Github username from before the @
-                    // It could either be in the format: username@ or github_id+username@
                     if (email.endsWith('@users.noreply.github.com')) {
                         const match = email.match(/^(\d+\+)?([^@]+)@users\.noreply\.github\.com$/);
                         if (match && match[2]) {
@@ -189,7 +246,6 @@ const defaultChangelogRenderer = async ({ projectGraph, changes, releaseVersion,
                             break;
                         }
                     }
-                    // Look up any other emails against the ungh.cc API
                     const { data } = await axios
                         .get(`https://ungh.cc/users/find/${email}`)
                         .catch(() => ({ data: { user: null } }));
@@ -206,110 +262,78 @@ const defaultChangelogRenderer = async ({ projectGraph, changes, releaseVersion,
         }));
         if (authors.length > 0) {
             markdownLines.push('', '### ' + '❤️  Thank You', '', ...authors
-                // Sort the contributors by name
                 .sort((a, b) => a.name.localeCompare(b.name))
                 .map((i) => {
-                // Tag the author's Github username if we were able to resolve it so that Github adds them as a contributor
                 const github = i.github ? ` @${i.github}` : '';
                 return `- ${i.name}${github}`;
             }));
         }
+        return markdownLines;
     }
-    return markdownLines.join('\n').trim();
-};
-exports.default = defaultChangelogRenderer;
-function applyAdditionalDependencyBumps({ markdownLines, dependencyBumps, releaseVersion, changelogRenderOptions, }) {
-    if (markdownLines.length === 0) {
-        markdownLines.push('', `${createVersionTitle(releaseVersion, changelogRenderOptions)}\n`, '');
-    }
-    else {
-        markdownLines.push('');
-    }
-    markdownLines.push('### 🧱 Updated Dependencies\n');
-    dependencyBumps.forEach(({ dependencyName, newVersion }) => {
-        markdownLines.push(`- Updated ${dependencyName} to ${newVersion}`);
-    });
-    markdownLines.push('');
-}
-function formatName(name = '') {
-    return name
-        .split(' ')
-        .map((p) => p.trim())
-        .join(' ');
-}
-function groupBy(items, key) {
-    const groups = {};
-    for (const item of items) {
-        groups[item[key]] = groups[item[key]] || [];
-        groups[item[key]].push(item);
-    }
-    return groups;
-}
-function formatChange(change, changelogRenderOptions, isVersionPlans, repoData) {
-    let description = change.description;
-    let extraLines = [];
-    let extraLinesStr = '';
-    if (description.includes('\n')) {
-        [description, ...extraLines] = description.split('\n');
-        // Align the extra lines with the start of the description for better readability
-        const indentation = '  ';
-        extraLinesStr = extraLines
-            .filter((l) => l.trim().length > 0)
-            .map((l) => `${indentation}${l}`)
-            .join('\n');
-    }
-    /**
-     * In version plans changelogs:
-     * - don't repeat the breaking change icon
-     * - don't render the scope
-     */
-    let changeLine = '- ' +
-        (!isVersionPlans && change.isBreaking ? '⚠️  ' : '') +
-        (!isVersionPlans && change.scope ? `**${change.scope.trim()}:** ` : '') +
-        description;
-    if (repoData && changelogRenderOptions.commitReferences) {
-        changeLine += (0, github_1.formatReferences)(change.githubReferences, repoData);
-    }
-    if (extraLinesStr) {
-        changeLine += '\n\n' + extraLinesStr;
-    }
-    return changeLine;
-}
-/**
- * It is common to add further information about a breaking change in the commit body,
- * and it is naturally that information that should be included in the BREAKING CHANGES
- * section of changelog, rather than repeating the commit title/description.
- */
-function extractBreakingChangeExplanation(message) {
-    if (!message) {
-        return null;
+    formatChange(change) {
+        let description = change.description;
+        let extraLines = [];
+        let extraLinesStr = '';
+        if (description.includes('\n')) {
+            [description, ...extraLines] = description.split('\n');
+            const indentation = '  ';
+            extraLinesStr = extraLines
+                .filter((l) => l.trim().length > 0)
+                .map((l) => `${indentation}${l}`)
+                .join('\n');
+        }
+        let changeLine = '- ' +
+            (!this.isVersionPlans && change.isBreaking ? '⚠️  ' : '') +
+            (!this.isVersionPlans && change.scope
+                ? `**${change.scope.trim()}:** `
+                : '') +
+            description;
+        if (this.repoData && this.changelogRenderOptions.commitReferences) {
+            changeLine += (0, github_1.formatReferences)(change.githubReferences, this.repoData);
+        }
+        if (extraLinesStr) {
+            changeLine += '\n\n' + extraLinesStr;
+        }
+        return changeLine;
     }
-    const breakingChangeIdentifier = 'BREAKING CHANGE:';
-    const startIndex = message.indexOf(breakingChangeIdentifier);
-    if (startIndex === -1) {
-        // "BREAKING CHANGE:" not found in the message
-        return null;
+    groupChangesByType() {
+        const typeGroups = {};
+        for (const change of this.relevantChanges) {
+            typeGroups[change.type] = typeGroups[change.type] || [];
+            typeGroups[change.type].push(change);
+        }
+        return typeGroups;
     }
-    const startOfBreakingChange = startIndex + breakingChangeIdentifier.length;
-    const endOfBreakingChange = message.indexOf('\n', startOfBreakingChange);
-    if (endOfBreakingChange === -1) {
-        // No newline character found, extract till the end of the message
-        return message.substring(startOfBreakingChange).trim();
+    groupChangesByScope(changes) {
+        const scopeGroups = {};
+        for (const change of changes) {
+            const scope = change.scope || '';
+            scopeGroups[scope] = scopeGroups[scope] || [];
+            scopeGroups[scope].push(change);
+        }
+        return scopeGroups;
     }
-    // Extract and return the breaking change message
-    return message.substring(startOfBreakingChange, endOfBreakingChange).trim();
-}
-function createVersionTitle(version, changelogRenderOptions) {
-    // Normalize by removing any leading `v` during comparison
-    const isMajorVersion = `${(0, semver_1.major)(version)}.0.0` === version.replace(/^v/, '');
-    let maybeDateStr = '';
-    if (changelogRenderOptions.versionTitleDate) {
-        // YYYY-MM-DD
-        const dateStr = new Date().toISOString().slice(0, 10);
-        maybeDateStr = ` (${dateStr})`;
+    extractBreakingChangeExplanation(message) {
+        if (!message) {
+            return null;
+        }
+        const breakingChangeIdentifier = 'BREAKING CHANGE:';
+        const startIndex = message.indexOf(breakingChangeIdentifier);
+        if (startIndex === -1) {
+            return null;
+        }
+        const startOfBreakingChange = startIndex + breakingChangeIdentifier.length;
+        const endOfBreakingChange = message.indexOf('\n', startOfBreakingChange);
+        if (endOfBreakingChange === -1) {
+            return message.substring(startOfBreakingChange).trim();
+        }
+        return message.substring(startOfBreakingChange, endOfBreakingChange).trim();
     }
-    if (isMajorVersion) {
-        return `# ${version}${maybeDateStr}`;
+    formatName(name = '') {
+        return name
+            .split(' ')
+            .map((p) => p.trim())
+            .join(' ');
     }
-    return `## ${version}${maybeDateStr}`;
 }
+exports.default = DefaultChangelogRenderer;

package/src/command-line/add/add.js

@@ -103,8 +103,8 @@ async function initializePlugin(pkgName, options, nxJson) {
         if (options.__overrides_unparsed__.length) {
             args.push(...options.__overrides_unparsed__);
         }
-        await (0, child_process_2.runNxAsync)(`g ${pkgName}:${initGenerator} ${args.join(' ')}`, {
-            silent: !options.verbose,
+        (0, child_process_2.runNxSync)(`g ${pkgName}:${initGenerator} ${args.join(' ')}`, {
+            stdio: [0, 1, 2],
         });
     }
     catch (e) {

package/src/command-line/nx-commands.js

@@ -29,6 +29,7 @@ const command_object_23 = require("./login/command-object");
 const command_object_24 = require("./logout/command-object");
 const command_objects_1 = require("./deprecated/command-objects");
 const command_object_25 = require("./sync/command-object");
+const output_1 = require("../utils/output");
 // Ensure that the output takes up the available width of the terminal.
 yargs.wrap(yargs.terminalWidth());
 exports.parserConfiguration = {
@@ -82,26 +83,46 @@ exports.commandsObject = yargs
     .command(command_object_23.yargsLoginCommand)
     .command(command_object_24.yargsLogoutCommand)
     .command(resolveConformanceCommandObject())
+    .command(resolveConformanceCheckCommandObject())
     .scriptName('nx')
     .help()
     // NOTE: we handle --version in nx.ts, this just tells yargs that the option exists
     // so that it shows up in help. The default yargs implementation of --version is not
     // hit, as the implementation in nx.ts is hit first and calls process.exit(0).
     .version();
+function createMissingConformanceCommand(command) {
+    return {
+        command,
+        // Hide from --help output in the common case of not having the plugin installed
+        describe: false,
+        handler: () => {
+            output_1.output.error({
+                title: `${command} is not available`,
+                bodyLines: [
+                    `In order to use the \`nx ${command}\` command you must have an active Powerpack license and the \`@nx/powerpack-conformance\` plugin installed.`,
+                    '',
+                    'To learn more, visit https://nx.dev/features/powerpack/conformance',
+                ],
+            });
+            process.exit(1);
+        },
+    };
+}
 function resolveConformanceCommandObject() {
     try {
         const { yargsConformanceCommand } = require('@nx/powerpack-conformance');
         return yargsConformanceCommand;
     }
-    catch (e) {
-        return {
-            command: 'conformance',
-            // Hide from --help output in the common case of not having the plugin installed
-            describe: false,
-            handler: () => {
-                // TODO: Add messaging to help with learning more about powerpack and conformance
-                process.exit(1);
-            },
-        };
+    catch {
+        return createMissingConformanceCommand('conformance');
+    }
+}
+function resolveConformanceCheckCommandObject() {
+    try {
+        const { yargsConformanceCheckCommand, } = require('@nx/powerpack-conformance');
+        return yargsConformanceCheckCommand;
+    }
+    catch {
+        return createMissingConformanceCommand('conformance:check');
     }
 }