nx 17.0.3 → 17.0.5

package/src/command-line/release/utils/exec-command.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.execCommand = void 0;
+const node_child_process_1 = require("node:child_process");
+async function execCommand(cmd, args, options) {
+    return new Promise((resolve, reject) => {
+        const child = (0, node_child_process_1.spawn)(cmd, args, {
+            ...options,
+            stdio: ['pipe', 'pipe', 'pipe'], // stdin, stdout, stderr
+            encoding: 'utf-8',
+        });
+        let stdout = '';
+        let stderr = '';
+        child.stdout.on('data', (chunk) => {
+            stdout += chunk;
+        });
+        child.stderr.on('data', (chunk) => {
+            stderr += chunk;
+        });
+        child.on('error', (error) => {
+            reject(error);
+        });
+        child.on('close', (code) => {
+            if (code !== 0) {
+                reject(stderr ||
+                    `Unknown error occurred while running "${cmd} ${args.join(' ')}"`);
+            }
+            else {
+                resolve(stdout);
+            }
+        });
+    });
+}
+exports.execCommand = execCommand;

package/src/command-line/release/utils/git.d.ts

@@ -19,8 +19,41 @@ export interface GitCommit extends RawGitCommit {
     references: Reference[];
     authors: GitCommitAuthor[];
     isBreaking: boolean;
+    affectedFiles: string[];
+    revertedHashes: string[];
 }
-export declare function getLastGitTag(): Promise<any>;
+export declare function getLatestGitTagForPattern(releaseTagPattern: string, additionalInterpolationData?: {}): Promise<{
+    tag: string;
+    extractedVersion: string;
+} | null>;
 export declare function getGitDiff(from: string | undefined, to?: string): Promise<RawGitCommit[]>;
+export declare function gitAdd({ changedFiles, dryRun, verbose, logFn, }: {
+    changedFiles: string[];
+    dryRun?: boolean;
+    verbose?: boolean;
+    logFn?: (...messages: string[]) => void;
+}): Promise<string>;
+export declare function gitCommit({ messages, additionalArgs, dryRun, verbose, logFn, }: {
+    messages: string[];
+    additionalArgs?: string;
+    dryRun?: boolean;
+    verbose?: boolean;
+    logFn?: (message: string) => void;
+}): Promise<string>;
+export declare function gitTag({ tag, message, additionalArgs, dryRun, verbose, logFn, }: {
+    tag: string;
+    message?: string;
+    additionalArgs?: string;
+    dryRun?: boolean;
+    verbose?: boolean;
+    logFn?: (message: string) => void;
+}): Promise<string>;
+export declare function gitPush({ gitRemote, dryRun, verbose, }: {
+    gitRemote?: string;
+    dryRun?: boolean;
+    verbose?: boolean;
+}): Promise<void>;
 export declare function parseCommits(commits: RawGitCommit[]): GitCommit[];
 export declare function parseGitCommit(commit: RawGitCommit): GitCommit | null;
+export declare function getCommitHash(ref: string): Promise<string>;
+export declare function getFirstGitCommit(): Promise<string>;

package/src/command-line/release/utils/git.js

@@ -1,21 +1,73 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseGitCommit = exports.parseCommits = exports.getGitDiff = exports.getLastGitTag = void 0;
+exports.getFirstGitCommit = exports.getCommitHash = exports.parseGitCommit = exports.parseCommits = exports.gitPush = exports.gitTag = exports.gitCommit = exports.gitAdd = exports.getGitDiff = exports.getLatestGitTagForPattern = void 0;
 /**
  * Special thanks to changelogen for the original inspiration for many of these utilities:
  * https://github.com/unjs/changelogen
  */
-const node_child_process_1 = require("node:child_process");
-async function getLastGitTag() {
-    const r = await execCommand('git', ['describe', '--tags', '--abbrev=0'])
-        .then((r) => r.split('\n').filter(Boolean))
-        .catch(() => []);
-    return r.at(-1);
+const utils_1 = require("../../../tasks-runner/utils");
+const exec_command_1 = require("./exec-command");
+function escapeRegExp(string) {
+    return string.replace(/[/\-\\^$*+?.()|[\]{}]/g, '\\$&');
 }
-exports.getLastGitTag = getLastGitTag;
+// https://semver.org/#is-there-a-suggested-regular-expression-regex-to-check-a-semver-string
+const SEMVER_REGEX = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/g;
+async function getLatestGitTagForPattern(releaseTagPattern, additionalInterpolationData = {}) {
+    try {
+        let tags;
+        tags = await (0, exec_command_1.execCommand)('git', [
+            'tag',
+            '--sort',
+            '-v:refname',
+            '--merged',
+        ]).then((r) => r
+            .trim()
+            .split('\n')
+            .map((t) => t.trim())
+            .filter(Boolean));
+        if (!tags.length) {
+            // try again, but include all tags on the repo instead of just --merged ones
+            tags = await (0, exec_command_1.execCommand)('git', ['tag', '--sort', '-v:refname']).then((r) => r
+                .trim()
+                .split('\n')
+                .map((t) => t.trim())
+                .filter(Boolean));
+        }
+        if (!tags.length) {
+            return null;
+        }
+        const interpolatedTagPattern = (0, utils_1.interpolate)(releaseTagPattern, {
+            version: '%v%',
+            projectName: '%p%',
+            ...additionalInterpolationData,
+        });
+        const tagRegexp = `^${escapeRegExp(interpolatedTagPattern)
+            .replace('%v%', '(.+)')
+            .replace('%p%', '(.+)')}`;
+        const matchingSemverTags = tags.filter((tag) => 
+        // Do the match against SEMVER_REGEX to ensure that we skip tags that aren't valid semver versions
+        !!tag.match(tagRegexp) &&
+            tag.match(tagRegexp).some((r) => r.match(SEMVER_REGEX)));
+        if (!matchingSemverTags.length) {
+            return null;
+        }
+        const [latestMatchingTag, ...rest] = matchingSemverTags[0].match(tagRegexp);
+        const version = rest.filter((r) => {
+            return r.match(SEMVER_REGEX);
+        })[0];
+        return {
+            tag: latestMatchingTag,
+            extractedVersion: version,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+exports.getLatestGitTagForPattern = getLatestGitTagForPattern;
 async function getGitDiff(from, to = 'HEAD') {
     // https://git-scm.com/docs/pretty-formats
-    const r = await execCommand('git', [
+    const r = await (0, exec_command_1.execCommand)('git', [
         '--no-pager',
         'log',
         `${from ? `${from}...` : ''}${to}`,
@@ -38,6 +90,141 @@ async function getGitDiff(from, to = 'HEAD') {
     });
 }
 exports.getGitDiff = getGitDiff;
+async function gitAdd({ changedFiles, dryRun, verbose, logFn, }) {
+    logFn = logFn || console.log;
+    let ignoredFiles = [];
+    let filesToAdd = [];
+    for (const f of changedFiles) {
+        const isFileIgnored = await isIgnored(f);
+        if (isFileIgnored) {
+            ignoredFiles.push(f);
+        }
+        else {
+            filesToAdd.push(f);
+        }
+    }
+    if (verbose && ignoredFiles.length) {
+        logFn(`Will not add the following files because they are ignored by git:`);
+        ignoredFiles.forEach((f) => logFn(f));
+    }
+    if (!filesToAdd.length) {
+        logFn('\nNo files to stage. Skipping git add.');
+        return;
+    }
+    const commandArgs = ['add', ...filesToAdd];
+    const message = dryRun
+        ? `Would stage files in git with the following command, but --dry-run was set:`
+        : `Staging files in git with the following command:`;
+    if (verbose) {
+        logFn(message);
+        logFn(`git ${commandArgs.join(' ')}`);
+    }
+    if (dryRun) {
+        return;
+    }
+    return (0, exec_command_1.execCommand)('git', commandArgs);
+}
+exports.gitAdd = gitAdd;
+async function isIgnored(filePath) {
+    try {
+        // This command will error if the file is not ignored
+        await (0, exec_command_1.execCommand)('git', ['check-ignore', filePath]);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function gitCommit({ messages, additionalArgs, dryRun, verbose, logFn, }) {
+    logFn = logFn || console.log;
+    const commandArgs = ['commit'];
+    for (const message of messages) {
+        commandArgs.push('--message', message);
+    }
+    if (additionalArgs) {
+        commandArgs.push(...additionalArgs.split(' '));
+    }
+    if (verbose) {
+        logFn(dryRun
+            ? `Would commit all previously staged files in git with the following command, but --dry-run was set:`
+            : `Committing files in git with the following command:`);
+        logFn(`git ${commandArgs.join(' ')}`);
+    }
+    if (dryRun) {
+        return;
+    }
+    let hasStagedFiles = false;
+    try {
+        // This command will error if there are staged changes
+        await (0, exec_command_1.execCommand)('git', ['diff-index', '--quiet', 'HEAD', '--cached']);
+    }
+    catch {
+        hasStagedFiles = true;
+    }
+    if (!hasStagedFiles) {
+        logFn('\nNo staged files found. Skipping commit.');
+        return;
+    }
+    return (0, exec_command_1.execCommand)('git', commandArgs);
+}
+exports.gitCommit = gitCommit;
+async function gitTag({ tag, message, additionalArgs, dryRun, verbose, logFn, }) {
+    logFn = logFn || console.log;
+    const commandArgs = [
+        'tag',
+        // Create an annotated tag (recommended for releases here: https://git-scm.com/docs/git-tag)
+        '--annotate',
+        tag,
+        '--message',
+        message || tag,
+    ];
+    if (additionalArgs) {
+        commandArgs.push(...additionalArgs.split(' '));
+    }
+    if (verbose) {
+        logFn(dryRun
+            ? `Would tag the current commit in git with the following command, but --dry-run was set:`
+            : `Tagging the current commit in git with the following command:`);
+        logFn(`git ${commandArgs.join(' ')}`);
+    }
+    if (dryRun) {
+        return;
+    }
+    try {
+        return await (0, exec_command_1.execCommand)('git', commandArgs);
+    }
+    catch (err) {
+        throw new Error(`Unexpected error when creating tag ${tag}:\n\n${err}`);
+    }
+}
+exports.gitTag = gitTag;
+async function gitPush({ gitRemote, dryRun, verbose, }) {
+    const commandArgs = [
+        'push',
+        // NOTE: It's important we use --follow-tags, and not --tags, so that we are precise about what we are pushing
+        '--follow-tags',
+        '--no-verify',
+        '--atomic',
+        // Set custom git remote if provided
+        ...(gitRemote ? [gitRemote] : []),
+    ];
+    if (verbose) {
+        console.log(dryRun
+            ? `Would push the current branch to the remote with the following command, but --dry-run was set:`
+            : `Pushing the current branch to the remote with the following command:`);
+        console.log(`git ${commandArgs.join(' ')}`);
+    }
+    if (dryRun) {
+        return;
+    }
+    try {
+        await (0, exec_command_1.execCommand)('git', commandArgs);
+    }
+    catch (err) {
+        throw new Error(`Unexpected git push error: ${err}`);
+    }
+}
+exports.gitPush = gitPush;
 function parseCommits(commits) {
     return commits.map((commit) => parseGitCommit(commit)).filter(Boolean);
 }
@@ -48,14 +235,15 @@ const ConventionalCommitRegex = /(?<type>[a-z]+)(\((?<scope>.+)\))?(?<breaking>!
 const CoAuthoredByRegex = /co-authored-by:\s*(?<name>.+)(<(?<email>.+)>)/gim;
 const PullRequestRE = /\([ a-z]*(#\d+)\s*\)/gm;
 const IssueRE = /(#\d+)/gm;
+const ChangedFileRegex = /(A|M|D|R\d*|C\d*)\t([^\t\n]*)\t?(.*)?/gm;
+const RevertHashRE = /This reverts commit (?<hash>[\da-f]{40})./gm;
 function parseGitCommit(commit) {
     const match = commit.message.match(ConventionalCommitRegex);
     if (!match) {
         return null;
     }
-    const type = match.groups.type;
     const scope = match.groups.scope || '';
-    const isBreaking = Boolean(match.groups.breaking);
+    const isBreaking = Boolean(match.groups.breaking) || commit.body.includes('BREAKING CHANGE:');
     let description = match.groups.description;
     // Extract references from message
     const references = [];
@@ -70,6 +258,17 @@ function parseGitCommit(commit) {
     references.push({ value: commit.shortHash, type: 'hash' });
     // Remove references and normalize
     description = description.replace(PullRequestRE, '').trim();
+    let type = match.groups.type;
+    // Extract any reverted hashes, if applicable
+    const revertedHashes = [];
+    const matchedHashes = commit.body.matchAll(RevertHashRE);
+    for (const matchedHash of matchedHashes) {
+        revertedHashes.push(matchedHash.groups.hash);
+    }
+    if (revertedHashes.length) {
+        type = 'revert';
+        description = commit.message;
+    }
     // Find all authors
     const authors = [commit.author];
     for (const match of commit.body.matchAll(CoAuthoredByRegex)) {
@@ -78,6 +277,10 @@ function parseGitCommit(commit) {
             email: (match.groups.email || '').trim(),
         });
     }
+    // Extract file changes from commit body
+    const affectedFiles = Array.from(commit.body.matchAll(ChangedFileRegex)).reduce((prev, [fullLine, changeType, file1, file2]) => 
+    // file2 only exists for some change types, such as renames
+    file2 ? [...prev, file1, file2] : [...prev, file1], []);
     return {
         ...commit,
         authors,
@@ -86,30 +289,31 @@ function parseGitCommit(commit) {
         scope,
         references,
         isBreaking,
+        revertedHashes,
+        affectedFiles,
     };
 }
 exports.parseGitCommit = parseGitCommit;
-async function execCommand(cmd, args, options) {
-    return new Promise((resolve, reject) => {
-        const child = (0, node_child_process_1.spawn)(cmd, args, {
-            ...options,
-            stdio: ['pipe', 'pipe', 'pipe'],
-            encoding: 'utf-8',
-        });
-        let stdout = '';
-        child.stdout.on('data', (chunk) => {
-            stdout += chunk;
-        });
-        child.on('error', (error) => {
-            reject(error);
-        });
-        child.on('close', (code) => {
-            if (code !== 0) {
-                reject(new Error(`Command failed with exit code ${code}`));
-            }
-            else {
-                resolve(stdout);
-            }
-        });
-    });
+async function getCommitHash(ref) {
+    try {
+        return (await (0, exec_command_1.execCommand)('git', ['rev-parse', ref])).trim();
+    }
+    catch (e) {
+        throw new Error(`Unknown revision: ${ref}`);
+    }
+}
+exports.getCommitHash = getCommitHash;
+async function getFirstGitCommit() {
+    try {
+        return (await (0, exec_command_1.execCommand)('git', [
+            'rev-list',
+            '--max-parents=0',
+            'HEAD',
+            '--first-parent',
+        ])).trim();
+    }
+    catch (e) {
+        throw new Error(`Unable to find first commit in git history`);
+    }
 }
+exports.getFirstGitCommit = getFirstGitCommit;

package/src/command-line/release/utils/github.d.ts

@@ -1,4 +1,5 @@
 import { Reference } from './git';
+import { ReleaseVersion } from './shared';
 export type RepoSlug = `${string}/${string}`;
 export interface GithubRequestConfig {
     repo: string;
@@ -7,17 +8,16 @@ export interface GithubRequestConfig {
 export interface GithubRelease {
     id?: string;
     tag_name: string;
+    target_commitish?: string;
     name?: string;
     body?: string;
     draft?: boolean;
     prerelease?: boolean;
 }
 export declare function getGitHubRepoSlug(remoteName?: string): RepoSlug;
-export declare function createOrUpdateGithubRelease(githubRequestConfig: GithubRequestConfig, release: {
-    version: string;
-    body: string;
-    prerelease: boolean;
-}, existingGithubReleaseForVersion?: GithubRelease): Promise<void>;
+export declare function createOrUpdateGithubRelease(releaseVersion: ReleaseVersion, changelogContents: string, latestCommit: string, { dryRun }: {
+    dryRun: boolean;
+}): Promise<void>;
 export declare function resolveGithubToken(): Promise<string | null>;
 export declare function getGithubReleaseByTag(config: GithubRequestConfig, tag: string): Promise<GithubRelease>;
 export declare function formatReferences(references: Reference[], repoSlug: RepoSlug): string;

package/src/command-line/release/utils/github.js

@@ -2,10 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.formatReferences = exports.getGithubReleaseByTag = exports.resolveGithubToken = exports.createOrUpdateGithubRelease = exports.getGitHubRepoSlug = void 0;
 const chalk = require("chalk");
+const enquirer_1 = require("enquirer");
 const node_child_process_1 = require("node:child_process");
 const node_fs_1 = require("node:fs");
 const node_os_1 = require("node:os");
-const devkit_exports_1 = require("../../../devkit-exports");
+const output_1 = require("../../../utils/output");
+const path_1 = require("../../../utils/path");
+const print_changes_1 = require("./print-changes");
+const shared_1 = require("./shared");
 // axios types and values don't seem to match
 const _axios = require("axios");
 const axios = _axios;
@@ -16,7 +20,7 @@ function getGitHubRepoSlug(remoteName = 'origin') {
             stdio: 'pipe',
         }).trim();
         // Extract the 'user/repo' part from the URL
-        const regex = /github\.com[/:]([\w-]+\/[\w-]+)\.git/;
+        const regex = /github\.com[/:]([\w-]+\/[\w-]+)/;
         const match = remoteUrl.match(regex);
         if (match && match[1]) {
             return match[1];
@@ -30,8 +34,109 @@ function getGitHubRepoSlug(remoteName = 'origin') {
     }
 }
 exports.getGitHubRepoSlug = getGitHubRepoSlug;
-async function createOrUpdateGithubRelease(githubRequestConfig, release, existingGithubReleaseForVersion) {
+async function createOrUpdateGithubRelease(releaseVersion, changelogContents, latestCommit, { dryRun }) {
+    const githubRepoSlug = getGitHubRepoSlug();
+    if (!githubRepoSlug) {
+        output_1.output.error({
+            title: `Unable to create a GitHub release because the GitHub repo slug could not be determined.`,
+            bodyLines: [
+                `Please ensure you have a valid GitHub remote configured. You can run \`git remote -v\` to list your current remotes.`,
+            ],
+        });
+        process.exit(1);
+    }
+    const token = await resolveGithubToken();
+    const githubRequestConfig = {
+        repo: githubRepoSlug,
+        token,
+    };
+    let existingGithubReleaseForVersion;
+    try {
+        existingGithubReleaseForVersion = await getGithubReleaseByTag(githubRequestConfig, releaseVersion.gitTag);
+    }
+    catch (err) {
+        if (err.response?.status === 401) {
+            output_1.output.error({
+                title: `Unable to resolve data via the GitHub API. You can use any of the following options to resolve this:`,
+                bodyLines: [
+                    '- Set the `GITHUB_TOKEN` or `GH_TOKEN` environment variable to a valid GitHub token with `repo` scope',
+                    '- Have an active session via the official gh CLI tool (https://cli.github.com) in your current terminal',
+                ],
+            });
+            process.exit(1);
+        }
+        if (err.response?.status === 404) {
+            // No existing release found, this is fine
+        }
+        else {
+            // Rethrow unknown errors for now
+            throw err;
+        }
+    }
+    const logTitle = `https://github.com/${githubRepoSlug}/releases/tag/${releaseVersion.gitTag}`;
+    if (existingGithubReleaseForVersion) {
+        console.error(`${chalk.white('UPDATE')} ${logTitle}${dryRun ? chalk.keyword('orange')(' [dry-run]') : ''}`);
+    }
+    else {
+        console.error(`${chalk.green('CREATE')} ${logTitle}${dryRun ? chalk.keyword('orange')(' [dry-run]') : ''}`);
+    }
+    console.log('');
+    (0, print_changes_1.printDiff)(existingGithubReleaseForVersion ? existingGithubReleaseForVersion.body : '', changelogContents, 3, shared_1.noDiffInChangelogMessage);
+    if (!dryRun) {
+        await createOrUpdateGithubReleaseInternal(githubRequestConfig, {
+            version: releaseVersion.gitTag,
+            prerelease: releaseVersion.isPrerelease,
+            body: changelogContents,
+            commit: latestCommit,
+        }, existingGithubReleaseForVersion);
+    }
+}
+exports.createOrUpdateGithubRelease = createOrUpdateGithubRelease;
+async function createOrUpdateGithubReleaseInternal(githubRequestConfig, release, existingGithubReleaseForVersion) {
     const result = await syncGithubRelease(githubRequestConfig, release, existingGithubReleaseForVersion);
+    /**
+     * If something went wrong POSTing to Github we can still pre-populate the web form on github.com
+     * to allow the user to manually complete the release if they so choose.
+     */
+    if (result.status === 'manual') {
+        if (result.error) {
+            process.exitCode = 1;
+            if (result.error.response?.data) {
+                // There's a nicely formatted error from GitHub we can display to the user
+                output_1.output.error({
+                    title: `A GitHub API Error occurred when creating/updating the release`,
+                    bodyLines: [
+                        `GitHub Error: ${JSON.stringify(result.error.response.data)}`,
+                        `---`,
+                        `Request Data:`,
+                        `Repo: ${githubRequestConfig.repo}`,
+                        `Token: ${githubRequestConfig.token}`,
+                        `Body: ${JSON.stringify(result.requestData)}`,
+                    ],
+                });
+            }
+            else {
+                console.log(result.error);
+                console.error(`An unknown error occurred while trying to create a release on GitHub, please report this on https://github.com/nrwl/nx (NOTE: make sure to redact your GitHub token from the error message!)`);
+            }
+        }
+        const shouldContinueInGitHub = await promptForContinueInGitHub();
+        if (!shouldContinueInGitHub) {
+            return;
+        }
+        const open = require('open');
+        await open(result.url)
+            .then(() => {
+            console.info(`\nFollow up in the browser to manually create the release:\n\n` +
+                chalk.underline(chalk.cyan(result.url)) +
+                `\n`);
+        })
+            .catch(() => {
+            console.info(`Open this link to manually create a release: \n` +
+                chalk.underline(chalk.cyan(result.url)) +
+                '\n');
+        });
+    }
     /**
      * If something went wrong POSTing to Github we can still pre-populate the web form on github.com
      * to allow the user to manually complete the release.
@@ -53,7 +158,32 @@ async function createOrUpdateGithubRelease(githubRequestConfig, release, existin
         });
     }
 }
-exports.createOrUpdateGithubRelease = createOrUpdateGithubRelease;
+async function promptForContinueInGitHub() {
+    try {
+        const reply = await (0, enquirer_1.prompt)([
+            {
+                name: 'open',
+                message: 'Do you want to finish creating the release manually in your browser?',
+                type: 'autocomplete',
+                choices: [
+                    {
+                        name: 'Yes',
+                        hint: 'It will pre-populate the form for you',
+                    },
+                    {
+                        name: 'No',
+                    },
+                ],
+                initial: 0,
+            },
+        ]);
+        return reply.open === 'Yes';
+    }
+    catch (e) {
+        // Handle the case where the user exits the prompt with ctrl+c
+        process.exit(1);
+    }
+}
 async function syncGithubRelease(githubRequestConfig, release, existingGithubReleaseForVersion) {
     const ghRelease = {
         tag_name: release.version,
@@ -64,7 +194,10 @@ async function syncGithubRelease(githubRequestConfig, release, existingGithubRel
     try {
         const newGhRelease = await (existingGithubReleaseForVersion
             ? updateGithubRelease(githubRequestConfig, existingGithubReleaseForVersion.id, ghRelease)
-            : createGithubRelease(githubRequestConfig, ghRelease));
+            : createGithubRelease(githubRequestConfig, {
+                ...ghRelease,
+                target_commitish: release.commit,
+            }));
         return {
             status: existingGithubReleaseForVersion ? 'updated' : 'created',
             id: newGhRelease.id,
@@ -76,6 +209,7 @@ async function syncGithubRelease(githubRequestConfig, release, existingGithubRel
             status: 'manual',
             error,
             url: githubNewReleaseURL(githubRequestConfig, release),
+            requestData: ghRelease,
         };
     }
 }
@@ -86,12 +220,25 @@ async function resolveGithubToken() {
         return tokenFromEnv;
     }
     // Try and resolve from gh CLI installation
-    const ghCLIPath = (0, devkit_exports_1.joinPathFragments)(process.env.XDG_CONFIG_HOME || (0, devkit_exports_1.joinPathFragments)((0, node_os_1.homedir)(), '.config'), 'gh', 'hosts.yml');
+    const ghCLIPath = (0, path_1.joinPathFragments)(process.env.XDG_CONFIG_HOME || (0, path_1.joinPathFragments)((0, node_os_1.homedir)(), '.config'), 'gh', 'hosts.yml');
     if ((0, node_fs_1.existsSync)(ghCLIPath)) {
         const yamlContents = await node_fs_1.promises.readFile(ghCLIPath, 'utf8');
         const { load } = require('@zkochan/js-yaml');
         const ghCLIConfig = load(yamlContents);
-        return ghCLIConfig['github.com'].oauth_token;
+        if (ghCLIConfig['github.com']) {
+            // Web based session (the token is already embedded in the config)
+            if (ghCLIConfig['github.com'].oauth_token) {
+                return ghCLIConfig['github.com'].oauth_token;
+            }
+            // SSH based session (we need to dynamically resolve a token using the CLI)
+            if (ghCLIConfig['github.com'].user &&
+                ghCLIConfig['github.com'].git_protocol === 'ssh') {
+                return (0, node_child_process_1.execSync)(`gh auth token`, {
+                    encoding: 'utf8',
+                    stdio: 'pipe',
+                }).trim();
+            }
+        }
     }
     return null;
 }
@@ -123,7 +270,7 @@ async function updateGithubRelease(config, id, body) {
     });
 }
 function githubNewReleaseURL(config, release) {
-    return `https://github.com/${config.repo}/releases/new?tag=v${release.version}&title=v${release.version}&body=${encodeURIComponent(release.body)}`;
+    return `https://github.com/${config.repo}/releases/new?tag=${release.version}&title=${release.version}&body=${encodeURIComponent(release.body)}`;
 }
 const providerToRefSpec = {
     github: { 'pull-request': 'pull', hash: 'commit', issue: 'issues' },

package/src/command-line/release/utils/markdown.js

@@ -2,7 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseChangelogMarkdown = void 0;
 function parseChangelogMarkdown(contents) {
-    const CHANGELOG_RELEASE_HEAD_RE = new RegExp('^#{2,}\\s+(\\d+\\.\\d+\\.\\d+)', 'gm');
+    /**
+     * The release header may include prerelease identifiers (e.g., -alpha.13),
+     * and major releases may use a single #, instead of the standard ## used
+     * for minor and patch releases. This regex matches all of these cases.
+     */
+    const CHANGELOG_RELEASE_HEAD_RE = new RegExp('^#+\\s*\\[?(\\d+\\.\\d+\\.\\d+(?:-[a-zA-Z0-9\\.]+)?)\\]?', 'gm');
     const headings = [...contents.matchAll(CHANGELOG_RELEASE_HEAD_RE)];
     const releases = [];
     for (let i = 0; i < headings.length; i++) {

package/src/command-line/release/utils/print-changes.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 import { Tree } from '../../../generators/tree';
 export declare function printDiff(before: string, after: string, contextLines?: number, noDiffMessage?: string): void;
-export declare function printChanges(tree: Tree, isDryRun: boolean, diffContextLines?: number, shouldPrintDryRunMessage?: boolean, noDiffMessage?: string, changePredicate?: (f: {
+export declare function printAndFlushChanges(tree: Tree, isDryRun: boolean, diffContextLines?: number, shouldPrintDryRunMessage?: boolean, noDiffMessage?: string, changePredicate?: (f: {
     path: string;
     content?: Buffer;
 }) => boolean): void;