release-please 17.8.0 → 17.9.0

package/build/src/github-api.d.ts

@@ -1,6 +1,6 @@
 import { Octokit } from '@octokit/rest';
 import { request } from '@octokit/request';
-import { Logger } from 'code-suggester/build/src/types';
+import { Logger } from './util/code-suggester/types';
 import { PullRequest } from './pull-request';
 import { Repository } from './repository';
 import { Release } from './release';

package/build/src/github.d.ts

@@ -9,7 +9,7 @@ import { Update } from './update';
 import { Release } from './release';
 import { GitHubApi, GitHubCreateOptions } from './github-api';
 import { GitHubFileContents } from '@google-automations/git-file-utils';
-import { Logger } from 'code-suggester/build/src/types';
+import { Logger } from './util/code-suggester/types';
 import { Scm, ScmChangeSet, ScmCommitIteratorOptions, ScmReleaseIteratorOptions, ScmTagIteratorOptions, ScmCreatePullRequestOptions, ScmReleaseOptions, ScmRelease, ScmTag, ScmUpdatePullRequestOptions } from './scm';
 type RequestBuilderType = typeof request;
 type DefaultFunctionType = RequestBuilderType['defaults'];

package/build/src/github.js

@@ -15,7 +15,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.sleepInMs = exports.GitHub = void 0;
 const request_error_1 = require("@octokit/request-error");
-const code_suggester_1 = require("code-suggester");
+const code_suggester_1 = require("./util/code-suggester");
 const errors_1 = require("./errors");
 const MAX_ISSUE_BODY_SIZE = 65536;
 const MAX_SLEEP_SECONDS = 20;

package/build/src/index.d.ts

@@ -14,4 +14,4 @@ export { Logger, setLogger } from './util/logger';
 export { GitHub } from './github';
 export declare const configSchema: any;
 export declare const manifestSchema: any;
-export declare const VERSION = "17.8.0";
+export declare const VERSION = "17.9.0";

package/build/src/index.js

@@ -36,6 +36,6 @@ Object.defineProperty(exports, "GitHub", { enumerable: true, get: function () {
 exports.configSchema = require('../../schemas/config.json');
 exports.manifestSchema = require('../../schemas/manifest.json');
 // x-release-please-start-version
-exports.VERSION = '17.8.0';
+exports.VERSION = '17.9.0';
 // x-release-please-end
 //# sourceMappingURL=index.js.map

package/build/src/local-github.d.ts

@@ -7,7 +7,7 @@ import { Update } from './update';
 import { Release } from './release';
 import { GitHubFileContents } from '@google-automations/git-file-utils';
 import { GitHubApi, GitHubCreateOptions } from './github-api';
-import { Logger } from 'code-suggester/build/src/types';
+import { Logger } from './util/code-suggester/types';
 export interface LocalGitHubCreateOptions extends GitHubCreateOptions {
     cloneDepth?: number;
     localRepoPath?: string;

package/build/src/local-github.js

@@ -20,7 +20,7 @@ const os = require("os");
 const child_process = require("child_process");
 const util = require("util");
 const readline = require("readline");
-const code_suggester_1 = require("code-suggester");
+const code_suggester_1 = require("./util/code-suggester");
 const execFile = util.promisify(child_process.execFile);
 const mkdtemp = fs.promises.mkdtemp;
 const errors_1 = require("./errors");

package/build/src/plugins/linked-versions.js

@@ -123,7 +123,7 @@ class LinkedVersions extends plugin_1.ManifestPlugin {
         // delegate to the merge plugin and add merged pull request
         if (inScopeCandidates.length > 0) {
             const merge = new merge_1.Merge(this.github, this.targetBranch, this.repositoryConfig, {
-                pullRequestTitlePattern: `chore\${scope}: release ${this.groupName} libraries`,
+                pullRequestTitlePattern: 'chore${scope}: release ' + this.groupName + ' libraries',
                 forceMerge: true,
                 headBranchName: branch_name_1.BranchName.ofGroupTargetBranch(this.groupName, this.targetBranch).toString(),
             });

package/build/src/util/code-suggester/default-options-handler.d.ts

@@ -0,0 +1,10 @@
+import { CreatePullRequest, CreatePullRequestUserOptions } from './types';
+/**
+ * Add defaults to GitHub Pull Request options.
+ * Preserves the empty string.
+ * For ESCMAScript, null/undefined values are preserved for required fields.
+ * Recommended with an object validation function to check empty strings and incorrect types.
+ * @param {PullRequestUserOptions} options the user-provided github pull request options
+ * @returns {CreatePullRequest} git hub context with defaults applied
+ */
+export declare function addPullRequestDefaults(options: CreatePullRequestUserOptions): CreatePullRequest;

package/build/src/util/code-suggester/default-options-handler.js

@@ -0,0 +1,45 @@
+"use strict";
+// Copyright 2026 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addPullRequestDefaults = void 0;
+const DEFAULT_BRANCH_NAME = 'code-suggestions';
+const DEFAULT_PRIMARY_BRANCH = 'main';
+/**
+ * Add defaults to GitHub Pull Request options.
+ * Preserves the empty string.
+ * For ESCMAScript, null/undefined values are preserved for required fields.
+ * Recommended with an object validation function to check empty strings and incorrect types.
+ * @param {PullRequestUserOptions} options the user-provided github pull request options
+ * @returns {CreatePullRequest} git hub context with defaults applied
+ */
+function addPullRequestDefaults(options) {
+    const pullRequestSettings = {
+        upstreamOwner: options.upstreamOwner,
+        upstreamRepo: options.upstreamRepo,
+        description: options.description,
+        title: options.title,
+        message: options.message,
+        force: options.force || false,
+        branch: typeof options.branch === 'string' ? options.branch : DEFAULT_BRANCH_NAME,
+        primary: typeof options.primary === 'string'
+            ? options.primary
+            : DEFAULT_PRIMARY_BRANCH,
+        maintainersCanModify: options.maintainersCanModify === false ? false : true,
+        filesPerCommit: options.filesPerCommit,
+    };
+    return pullRequestSettings;
+}
+exports.addPullRequestDefaults = addPullRequestDefaults;
+//# sourceMappingURL=default-options-handler.js.map

package/build/src/util/code-suggester/errors.d.ts

@@ -0,0 +1,4 @@
+export declare class CommitError extends Error {
+    cause: Error;
+    constructor(message: string, cause: Error);
+}

package/build/src/util/code-suggester/errors.js

@@ -0,0 +1,24 @@
+"use strict";
+// Copyright 2026 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommitError = void 0;
+class CommitError extends Error {
+    constructor(message, cause) {
+        super(message);
+        this.cause = cause;
+    }
+}
+exports.CommitError = CommitError;
+//# sourceMappingURL=errors.js.map

package/build/src/util/code-suggester/github/branch.d.ts

@@ -0,0 +1,45 @@
+import { RepoDomain } from '../types';
+import { Octokit } from '@octokit/rest';
+/**
+ * Create a new branch reference with the ref prefix
+ * @param {string} branchName name of the branch
+ */
+export declare function createRef(branchName: string): string;
+/**
+ * get branch commit HEAD SHA of a repository
+ * Throws an error if the branch cannot be found
+ * @param {Octokit} octokit The authenticated octokit instance
+ * @param {RepoDomain} origin The domain information of the remote origin repository
+ * @param {string} branch the name of the branch
+ * @returns {Promise<string>} branch commit HEAD SHA
+ */
+export declare function getBranchHead(octokit: Octokit, origin: RepoDomain, branch: string): Promise<string>;
+/**
+ * Determine if there is a branch with the provided name in the remote GitHub repository
+ * @param {Octokit} octokit The authenticated octokit instance
+ * @param {RepoDomain} remote The domain information of the remote repository
+ * @param {string} name The branch name to create on the repository
+ * @returns {Promise<boolean>} if there is a branch already existing in the remote GitHub repository
+ */
+export declare function existsBranchWithName(octokit: Octokit, remote: RepoDomain, name: string): Promise<boolean>;
+/**
+ * Create a branch on the remote repository if there is not an existing branch
+ * @param {Octokit} octokit The authenticated octokit instance
+ * @param {RepoDomain} remote The domain information of the remote origin repository
+ * @param {string} name The branch name to create on the origin repository
+ * @param {string} baseSha the sha that the base of the reference points to
+ * @param {boolean} duplicate whether there is an existing branch or not
+ * @returns {Promise<void>}
+ */
+export declare function createBranch(octokit: Octokit, remote: RepoDomain, name: string, baseSha: string, duplicate: boolean): Promise<void>;
+/**
+ * Create a GitHub branch given a remote origin.
+ * Throws an exception if octokit fails, or if the base branch is invalid
+ * @param {Octokit} octokit The authenticated octokit instance
+ * @param {RepoDomain} origin The domain information of the remote origin repository
+ * @param {RepoDomain} upstream The domain information of the remote upstream repository
+ * @param {string} name The branch name to create on the origin repository
+ * @param {string} baseBranch the name of the branch to base the new branch off of. Default is main
+ * @returns {Promise<string>} the base SHA for subsequent commits to be based off for the origin branch
+ */
+export declare function branch(octokit: Octokit, origin: RepoDomain, upstream: RepoDomain, name: string, baseBranch?: string): Promise<string>;

package/build/src/util/code-suggester/github/branch.js

@@ -0,0 +1,118 @@
+"use strict";
+// Copyright 2026 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.branch = exports.createBranch = exports.existsBranchWithName = exports.getBranchHead = exports.createRef = void 0;
+const logger_1 = require("../logger");
+const REF_PREFIX = 'refs/heads/';
+const DEFAULT_PRIMARY_BRANCH = 'main';
+/**
+ * Create a new branch reference with the ref prefix
+ * @param {string} branchName name of the branch
+ */
+function createRef(branchName) {
+    return REF_PREFIX + branchName;
+}
+exports.createRef = createRef;
+/**
+ * get branch commit HEAD SHA of a repository
+ * Throws an error if the branch cannot be found
+ * @param {Octokit} octokit The authenticated octokit instance
+ * @param {RepoDomain} origin The domain information of the remote origin repository
+ * @param {string} branch the name of the branch
+ * @returns {Promise<string>} branch commit HEAD SHA
+ */
+async function getBranchHead(octokit, origin, branch) {
+    const branchData = (await octokit.repos.getBranch({
+        owner: origin.owner,
+        repo: origin.repo,
+        branch,
+    })).data;
+    logger_1.logger.info(`Successfully found branch HEAD sha "${branchData.commit.sha}".`);
+    return branchData.commit.sha;
+}
+exports.getBranchHead = getBranchHead;
+/**
+ * Determine if there is a branch with the provided name in the remote GitHub repository
+ * @param {Octokit} octokit The authenticated octokit instance
+ * @param {RepoDomain} remote The domain information of the remote repository
+ * @param {string} name The branch name to create on the repository
+ * @returns {Promise<boolean>} if there is a branch already existing in the remote GitHub repository
+ */
+async function existsBranchWithName(octokit, remote, name) {
+    try {
+        const data = (await octokit.git.getRef({
+            owner: remote.owner,
+            repo: remote.repo,
+            ref: `heads/${name}`,
+        })).data;
+        return data.ref ? true : false;
+    }
+    catch (err) {
+        if (err.status === 404)
+            return false;
+        else
+            throw err;
+    }
+}
+exports.existsBranchWithName = existsBranchWithName;
+/**
+ * Create a branch on the remote repository if there is not an existing branch
+ * @param {Octokit} octokit The authenticated octokit instance
+ * @param {RepoDomain} remote The domain information of the remote origin repository
+ * @param {string} name The branch name to create on the origin repository
+ * @param {string} baseSha the sha that the base of the reference points to
+ * @param {boolean} duplicate whether there is an existing branch or not
+ * @returns {Promise<void>}
+ */
+async function createBranch(octokit, remote, name, baseSha, duplicate) {
+    if (!duplicate) {
+        const refData = (await octokit.git.createRef({
+            owner: remote.owner,
+            repo: remote.repo,
+            ref: createRef(name),
+            sha: baseSha,
+        })).data;
+        logger_1.logger.info(`Successfully created branch at ${refData.url}`);
+    }
+    else {
+        logger_1.logger.info('Skipping branch creation step...');
+    }
+}
+exports.createBranch = createBranch;
+/**
+ * Create a GitHub branch given a remote origin.
+ * Throws an exception if octokit fails, or if the base branch is invalid
+ * @param {Octokit} octokit The authenticated octokit instance
+ * @param {RepoDomain} origin The domain information of the remote origin repository
+ * @param {RepoDomain} upstream The domain information of the remote upstream repository
+ * @param {string} name The branch name to create on the origin repository
+ * @param {string} baseBranch the name of the branch to base the new branch off of. Default is main
+ * @returns {Promise<string>} the base SHA for subsequent commits to be based off for the origin branch
+ */
+async function branch(octokit, origin, upstream, name, baseBranch = DEFAULT_PRIMARY_BRANCH) {
+    // create branch from primary branch HEAD SHA
+    try {
+        const baseSha = await getBranchHead(octokit, upstream, baseBranch);
+        const duplicate = await existsBranchWithName(octokit, origin, name);
+        await createBranch(octokit, origin, name, baseSha, duplicate);
+        return baseSha;
+    }
+    catch (err) {
+        logger_1.logger.error('Error when creating branch');
+        throw err;
+    }
+}
+exports.branch = branch;
+//# sourceMappingURL=branch.js.map

package/build/src/util/code-suggester/github/commit-and-push.d.ts

@@ -0,0 +1,51 @@
+import { Changes, TreeObject, RepoDomain, BranchDomain } from '../types';
+import { Octokit } from '@octokit/rest';
+import { CreateCommitOptions } from './create-commit';
+/**
+ * Generate and return a GitHub tree object structure
+ * containing the target change data
+ * See https://developer.github.com/v3/git/trees/#tree-object
+ * @param {Changes} changes the set of repository changes
+ * @returns {TreeObject[]} The new GitHub changes
+ */
+export declare function generateTreeObjects(changes: Changes): TreeObject[];
+/**
+ * Upload and create a remote GitHub tree
+ * and resolves with the new tree SHA.
+ * Rejects if GitHub V3 API fails with the GitHub error response
+ * @param {Octokit} octokit The authenticated octokit instance
+ * @param {RepoDomain} origin the the remote repository to push changes to
+ * @param {string} refHead the base of the new commit(s)
+ * @param {TreeObject[]} tree the set of GitHub changes to upload
+ * @returns {Promise<string>} the GitHub tree SHA
+ * @throws {CommitError}
+ */
+export declare function createTree(octokit: Octokit, origin: RepoDomain, refHead: string, tree: TreeObject[]): Promise<string>;
+/**
+ * Update a reference to a SHA
+ * Rejects if GitHub V3 API fails with the GitHub error response
+ * @param {Octokit} octokit The authenticated octokit instance
+ * @param {BranchDomain} origin the the remote branch to push changes to
+ * @param {string} newSha the ref to update the commit HEAD to
+ * @param {boolean} force to force the commit changes given refHead
+ * @returns {Promise<void>}
+ */
+export declare function updateRef(octokit: Octokit, origin: BranchDomain, newSha: string, force: boolean): Promise<void>;
+interface CommitAndPushOptions extends CreateCommitOptions {
+    filesPerCommit?: number;
+}
+/**
+ * Given a set of changes, apply the commit(s) on top of the given branch's head and upload it to GitHub
+ * Rejects if GitHub V3 API fails with the GitHub error response
+ * @param {Octokit} octokit The authenticated octokit instance
+ * @param {string} refHead the base of the new commit(s)
+ * @param {Changes} changes the set of repository changes
+ * @param {RepoDomain} origin the the remote repository to push changes to
+ * @param {string} originBranchName the remote branch that will contain the new changes
+ * @param {string} commitMessage the message of the new commit
+ * @param {boolean} force to force the commit changes given refHead
+ * @returns {Promise<void>}
+ * @throws {CommitError}
+ */
+export declare function commitAndPush(octokit: Octokit, refHead: string, changes: Changes, originBranch: BranchDomain, commitMessage: string, force: boolean, options?: CommitAndPushOptions): Promise<void>;
+export {};

package/build/src/util/code-suggester/github/commit-and-push.js

@@ -0,0 +1,141 @@
+"use strict";
+// Copyright 2026 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.commitAndPush = exports.updateRef = exports.createTree = exports.generateTreeObjects = void 0;
+const logger_1 = require("../logger");
+const create_commit_1 = require("./create-commit");
+const errors_1 = require("../errors");
+const DEFAULT_FILES_PER_COMMIT = 100;
+/**
+ * Generate and return a GitHub tree object structure
+ * containing the target change data
+ * See https://developer.github.com/v3/git/trees/#tree-object
+ * @param {Changes} changes the set of repository changes
+ * @returns {TreeObject[]} The new GitHub changes
+ */
+function generateTreeObjects(changes) {
+    const tree = [];
+    changes.forEach((fileData, path) => {
+        if (fileData.content === null) {
+            // if no file content then file is deleted
+            tree.push({
+                path,
+                mode: fileData.mode,
+                type: 'blob',
+                sha: null,
+            });
+        }
+        else {
+            // update file with its content
+            tree.push({
+                path,
+                mode: fileData.mode,
+                type: 'blob',
+                content: fileData.content,
+            });
+        }
+    });
+    return tree;
+}
+exports.generateTreeObjects = generateTreeObjects;
+function* inGroupsOf(all, groupSize) {
+    for (let i = 0; i < all.length; i += groupSize) {
+        yield all.slice(i, i + groupSize);
+    }
+}
+/**
+ * Upload and create a remote GitHub tree
+ * and resolves with the new tree SHA.
+ * Rejects if GitHub V3 API fails with the GitHub error response
+ * @param {Octokit} octokit The authenticated octokit instance
+ * @param {RepoDomain} origin the the remote repository to push changes to
+ * @param {string} refHead the base of the new commit(s)
+ * @param {TreeObject[]} tree the set of GitHub changes to upload
+ * @returns {Promise<string>} the GitHub tree SHA
+ * @throws {CommitError}
+ */
+async function createTree(octokit, origin, refHead, tree) {
+    const oldTreeSha = (await octokit.git.getCommit({
+        owner: origin.owner,
+        repo: origin.repo,
+        commit_sha: refHead,
+    })).data.tree.sha;
+    logger_1.logger.info('Got the latest commit tree');
+    try {
+        const treeSha = (await octokit.git.createTree({
+            owner: origin.owner,
+            repo: origin.repo,
+            tree,
+            base_tree: oldTreeSha,
+        })).data.sha;
+        logger_1.logger.info(`Successfully created a tree with the desired changes with SHA ${treeSha}`);
+        return treeSha;
+    }
+    catch (e) {
+        throw new errors_1.CommitError(`Error adding to tree: ${refHead}`, e);
+    }
+}
+exports.createTree = createTree;
+/**
+ * Update a reference to a SHA
+ * Rejects if GitHub V3 API fails with the GitHub error response
+ * @param {Octokit} octokit The authenticated octokit instance
+ * @param {BranchDomain} origin the the remote branch to push changes to
+ * @param {string} newSha the ref to update the commit HEAD to
+ * @param {boolean} force to force the commit changes given refHead
+ * @returns {Promise<void>}
+ */
+async function updateRef(octokit, origin, newSha, force) {
+    logger_1.logger.info(`Updating reference heads/${origin.branch} to ${newSha}`);
+    try {
+        await octokit.git.updateRef({
+            owner: origin.owner,
+            repo: origin.repo,
+            ref: `heads/${origin.branch}`,
+            sha: newSha,
+            force,
+        });
+        logger_1.logger.info(`Successfully updated reference ${origin.branch} to ${newSha}`);
+    }
+    catch (e) {
+        throw new errors_1.CommitError(`Error updating ref heads/${origin.branch} to ${newSha}`, e);
+    }
+}
+exports.updateRef = updateRef;
+/**
+ * Given a set of changes, apply the commit(s) on top of the given branch's head and upload it to GitHub
+ * Rejects if GitHub V3 API fails with the GitHub error response
+ * @param {Octokit} octokit The authenticated octokit instance
+ * @param {string} refHead the base of the new commit(s)
+ * @param {Changes} changes the set of repository changes
+ * @param {RepoDomain} origin the the remote repository to push changes to
+ * @param {string} originBranchName the remote branch that will contain the new changes
+ * @param {string} commitMessage the message of the new commit
+ * @param {boolean} force to force the commit changes given refHead
+ * @returns {Promise<void>}
+ * @throws {CommitError}
+ */
+async function commitAndPush(octokit, refHead, changes, originBranch, commitMessage, force, options) {
+    var _a;
+    const filesPerCommit = (_a = options === null || options === void 0 ? void 0 : options.filesPerCommit) !== null && _a !== void 0 ? _a : DEFAULT_FILES_PER_COMMIT;
+    const tree = generateTreeObjects(changes);
+    for (const treeGroup of inGroupsOf(tree, filesPerCommit)) {
+        const treeSha = await createTree(octokit, originBranch, refHead, treeGroup);
+        refHead = await (0, create_commit_1.createCommit)(octokit, originBranch, refHead, treeSha, commitMessage, options);
+    }
+    await updateRef(octokit, originBranch, refHead, force);
+}
+exports.commitAndPush = commitAndPush;
+//# sourceMappingURL=commit-and-push.js.map

package/build/src/util/code-suggester/github/create-commit.d.ts

@@ -0,0 +1,20 @@
+import { Octokit } from '@octokit/rest';
+import { RepoDomain, CommitSigner, UserData } from '../types';
+export interface CreateCommitOptions {
+    signer?: CommitSigner;
+    author?: UserData;
+    committer?: UserData;
+}
+/**
+ * Create a commit with a repo snapshot SHA on top of the reference HEAD
+ * and resolves with the SHA of the commit.
+ * Rejects if GitHub V3 API fails with the GitHub error response
+ * @param {Octokit} octokit The authenticated octokit instance
+ * @param {RepoDomain} origin the the remote repository to push changes to
+ * @param {string} refHead the base of the new commit(s)
+ * @param {string} treeSha the tree SHA that this commit will point to
+ * @param {string} message the message of the new commit
+ * @returns {Promise<string>} the new commit SHA
+ * @see https://docs.github.com/en/rest/git/commits?apiVersion=2022-11-28#create-a-commit
+ */
+export declare function createCommit(octokit: Octokit, origin: RepoDomain, refHead: string, treeSha: string, message: string, options?: CreateCommitOptions): Promise<string>;

package/build/src/util/code-suggester/github/create-commit.js

@@ -0,0 +1,60 @@
+"use strict";
+// Copyright 2026 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCommit = void 0;
+const logger_1 = require("../logger");
+const errors_1 = require("../errors");
+/**
+ * Create a commit with a repo snapshot SHA on top of the reference HEAD
+ * and resolves with the SHA of the commit.
+ * Rejects if GitHub V3 API fails with the GitHub error response
+ * @param {Octokit} octokit The authenticated octokit instance
+ * @param {RepoDomain} origin the the remote repository to push changes to
+ * @param {string} refHead the base of the new commit(s)
+ * @param {string} treeSha the tree SHA that this commit will point to
+ * @param {string} message the message of the new commit
+ * @returns {Promise<string>} the new commit SHA
+ * @see https://docs.github.com/en/rest/git/commits?apiVersion=2022-11-28#create-a-commit
+ */
+async function createCommit(octokit, origin, refHead, treeSha, message, options = {}) {
+    try {
+        const signature = options.signer
+            ? await options.signer.generateSignature({
+                message,
+                tree: treeSha,
+                parents: [refHead],
+                author: options.author,
+                committer: options.committer,
+            })
+            : undefined;
+        const { data: { sha, url }, } = await octokit.git.createCommit({
+            owner: origin.owner,
+            repo: origin.repo,
+            message,
+            tree: treeSha,
+            parents: [refHead],
+            signature,
+            author: options.author,
+            committer: options.committer,
+        });
+        logger_1.logger.info(`Successfully created commit. See commit at ${url}`);
+        return sha;
+    }
+    catch (e) {
+        throw new errors_1.CommitError(`Error creating commit for: ${treeSha}`, e);
+    }
+}
+exports.createCommit = createCommit;
+//# sourceMappingURL=create-commit.js.map

package/build/src/util/code-suggester/github/fork.d.ts

@@ -0,0 +1,15 @@
+import { RepoDomain } from '../types';
+import { Octokit } from '@octokit/rest';
+/**
+ * Fork the GitHub owner's repository.
+ * Returns the fork owner and fork repo when the fork creation request to GitHub succeeds.
+ * Otherwise throws error.
+ *
+ * If fork already exists no new fork is created, no error occurs, and the existing Fork data is returned
+ * with the `updated_at` + any historical repo changes.
+ * @param {Octokit} octokit The authenticated octokit instance
+ * @param {RepoDomain} upstream upstream repository information
+ * @returns {Promise<RepoDomain>} the forked repository name, as well as the owner of that fork
+ */
+declare function fork(octokit: Octokit, upstream: RepoDomain): Promise<RepoDomain>;
+export { fork };

package/build/src/util/code-suggester/github/fork.js

@@ -0,0 +1,48 @@
+"use strict";
+// Copyright 2026 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fork = void 0;
+const logger_1 = require("../logger");
+/**
+ * Fork the GitHub owner's repository.
+ * Returns the fork owner and fork repo when the fork creation request to GitHub succeeds.
+ * Otherwise throws error.
+ *
+ * If fork already exists no new fork is created, no error occurs, and the existing Fork data is returned
+ * with the `updated_at` + any historical repo changes.
+ * @param {Octokit} octokit The authenticated octokit instance
+ * @param {RepoDomain} upstream upstream repository information
+ * @returns {Promise<RepoDomain>} the forked repository name, as well as the owner of that fork
+ */
+async function fork(octokit, upstream) {
+    try {
+        const forkedRepo = (await octokit.repos.createFork({
+            owner: upstream.owner,
+            repo: upstream.repo,
+        })).data;
+        const origin = {
+            repo: forkedRepo.name,
+            owner: forkedRepo.owner.login,
+        };
+        logger_1.logger.info(`Create fork request was successful for ${origin.owner}/${origin.repo}`);
+        return origin;
+    }
+    catch (err) {
+        logger_1.logger.error('Error when forking');
+        throw err;
+    }
+}
+exports.fork = fork;
+//# sourceMappingURL=fork.js.map

package/build/src/util/code-suggester/github/labels.d.ts

@@ -0,0 +1,14 @@
+import { BranchDomain, RepoDomain } from '../types';
+import { Octokit } from '@octokit/rest';
+/**
+ * Create a GitHub PR on the upstream organization's repo
+ * Throws an error if the GitHub API fails
+ * @param {Octokit} octokit The authenticated octokit instance
+ * @param {RepoDomain} upstream The upstream repository
+ * @param {BranchDomain} origin The remote origin information that contains the origin branch
+ * @param {number} issue_number The issue number to add labels to. Can also be a PR number
+ * @param {string[]} labels The list of labels to apply to the newly created PR. Default is []. the funciton will no-op.
+ * @returns {Promise<string[]>} The list of resulting labels after the addition of the given labels
+ */
+declare function addLabels(octokit: Octokit, upstream: RepoDomain, origin: BranchDomain, issue_number: number, labels?: string[]): Promise<string[]>;
+export { addLabels };

package/build/src/util/code-suggester/github/labels.js

@@ -0,0 +1,42 @@
+"use strict";
+// Copyright 2026 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addLabels = void 0;
+const logger_1 = require("../logger");
+/**
+ * Create a GitHub PR on the upstream organization's repo
+ * Throws an error if the GitHub API fails
+ * @param {Octokit} octokit The authenticated octokit instance
+ * @param {RepoDomain} upstream The upstream repository
+ * @param {BranchDomain} origin The remote origin information that contains the origin branch
+ * @param {number} issue_number The issue number to add labels to. Can also be a PR number
+ * @param {string[]} labels The list of labels to apply to the newly created PR. Default is []. the funciton will no-op.
+ * @returns {Promise<string[]>} The list of resulting labels after the addition of the given labels
+ */
+async function addLabels(octokit, upstream, origin, issue_number, labels) {
+    if (!labels || labels.length === 0) {
+        return [];
+    }
+    const labelsResponseData = (await octokit.issues.addLabels({
+        owner: upstream.owner,
+        repo: origin.repo,
+        issue_number: issue_number,
+        labels: labels,
+    })).data;
+    logger_1.logger.info(`Successfully added labels ${labels} to issue: ${issue_number}`);
+    return labelsResponseData.map(l => l.name);
+}
+exports.addLabels = addLabels;
+//# sourceMappingURL=labels.js.map

package/build/src/util/code-suggester/github/open-pull-request.d.ts

@@ -0,0 +1,16 @@
+import { BranchDomain, Description, RepoDomain } from '../types';
+import { Octokit } from '@octokit/rest';
+/**
+ * Create a GitHub PR on the upstream organization's repo
+ * Throws an error if the GitHub API fails
+ * @param {Octokit} octokit The authenticated octokit instance
+ * @param {RepoDomain} upstream The upstream repository
+ * @param {BranchDomain} origin The remote origin information that contains the origin branch
+ * @param {Description} description The pull request title and detailed description
+ * @param {boolean} maintainersCanModify Whether or not maintainers can modify the pull request. Default is true
+ * @param {string} upstreamPrimary The upstream repository's primary branch. Default is main.
+ * @param draft Open a DRAFT pull request.  Defaults to false.
+ * @returns {Promise<void>}
+ */
+declare function openPullRequest(octokit: Octokit, upstream: RepoDomain, origin: BranchDomain, description: Description, maintainersCanModify?: boolean, upstreamPrimary?: string, draft?: boolean): Promise<number>;
+export { openPullRequest };

package/build/src/util/code-suggester/github/open-pull-request.js

@@ -0,0 +1,56 @@
+"use strict";
+// Copyright 2026 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openPullRequest = void 0;
+const logger_1 = require("../logger");
+const DEFAULT_PRIMARY = 'main';
+/**
+ * Create a GitHub PR on the upstream organization's repo
+ * Throws an error if the GitHub API fails
+ * @param {Octokit} octokit The authenticated octokit instance
+ * @param {RepoDomain} upstream The upstream repository
+ * @param {BranchDomain} origin The remote origin information that contains the origin branch
+ * @param {Description} description The pull request title and detailed description
+ * @param {boolean} maintainersCanModify Whether or not maintainers can modify the pull request. Default is true
+ * @param {string} upstreamPrimary The upstream repository's primary branch. Default is main.
+ * @param draft Open a DRAFT pull request.  Defaults to false.
+ * @returns {Promise<void>}
+ */
+async function openPullRequest(octokit, upstream, origin, description, maintainersCanModify = true, upstreamPrimary = DEFAULT_PRIMARY, draft = false) {
+    const head = `${origin.owner}:${origin.branch}`;
+    const existingPullRequest = (await octokit.pulls.list({
+        owner: upstream.owner,
+        repo: origin.repo,
+        head,
+    })).data.find(pr => pr.head.label === head);
+    if (existingPullRequest) {
+        logger_1.logger.info(`Found existing pull request for reference ${origin.owner}:${origin.branch}. Skipping creating a new pull request.`);
+        return existingPullRequest.number;
+    }
+    const pullResponseData = (await octokit.pulls.create({
+        owner: upstream.owner,
+        repo: origin.repo,
+        title: description.title,
+        head: `${origin.owner}:${origin.branch}`,
+        base: upstreamPrimary,
+        body: description.body,
+        maintainer_can_modify: maintainersCanModify,
+        draft: draft,
+    })).data;
+    logger_1.logger.info(`Successfully opened pull request available at url: ${pullResponseData.url}.`);
+    return pullResponseData.number;
+}
+exports.openPullRequest = openPullRequest;
+//# sourceMappingURL=open-pull-request.js.map

package/build/src/util/code-suggester/index.d.ts

@@ -0,0 +1,28 @@
+import { Changes, CreatePullRequestUserOptions } from './types';
+import { Octokit } from '@octokit/rest';
+/**
+ * Make a new GitHub Pull Request with a set of changes applied on top of primary branch HEAD.
+ * The changes are committed into a new branch based on the upstream repository options using the authenticated Octokit account.
+ * Then a Pull Request is made from that branch.
+ *
+ * Also throws error if git data from the fork is not ready in 5 minutes.
+ *
+ * From the docs
+ * https://developer.github.com/v3/repos/forks/#create-a-fork
+ * """
+ * Forking a Repository happens asynchronously.
+ * You may have to wait a short period of time before you can access the git objects.
+ * If this takes longer than 5 minutes, be sure to contact GitHub Support or GitHub Premium Support.
+ * """
+ *
+ * If changes are empty then the workflow will not run.
+ * Rethrows an HttpError if Octokit GitHub API returns an error. HttpError Octokit access_token and client_secret headers redact all sensitive information.
+ * @param {Octokit} octokit The authenticated octokit instance, instantiated with an access token having permissiong to create a fork on the target repository
+ * @param {Changes | null | undefined} changes A set of changes. The changes may be empty
+ * @param {CreatePullRequestUserOptions} options The configuration for interacting with GitHub provided by the user.
+ * @returns {Promise<number>} the pull request number. Returns 0 if unsuccessful.
+ * @throws {CommitError} on failure during commit process
+ */
+declare function createPullRequest(octokit: Octokit, changes: Changes | null | undefined, options: CreatePullRequestUserOptions): Promise<number>;
+export { Changes, CommitData, CommitSigner } from './types';
+export { createPullRequest };

package/build/src/util/code-suggester/index.js

@@ -0,0 +1,110 @@
+"use strict";
+// Copyright 2026 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPullRequest = void 0;
+const logger_1 = require("./logger");
+const default_options_handler_1 = require("./default-options-handler");
+const retry = require("async-retry");
+const branch_1 = require("./github/branch");
+const fork_1 = require("./github/fork");
+const commit_and_push_1 = require("./github/commit-and-push");
+const open_pull_request_1 = require("./github/open-pull-request");
+const labels_1 = require("./github/labels");
+/**
+ * Make a new GitHub Pull Request with a set of changes applied on top of primary branch HEAD.
+ * The changes are committed into a new branch based on the upstream repository options using the authenticated Octokit account.
+ * Then a Pull Request is made from that branch.
+ *
+ * Also throws error if git data from the fork is not ready in 5 minutes.
+ *
+ * From the docs
+ * https://developer.github.com/v3/repos/forks/#create-a-fork
+ * """
+ * Forking a Repository happens asynchronously.
+ * You may have to wait a short period of time before you can access the git objects.
+ * If this takes longer than 5 minutes, be sure to contact GitHub Support or GitHub Premium Support.
+ * """
+ *
+ * If changes are empty then the workflow will not run.
+ * Rethrows an HttpError if Octokit GitHub API returns an error. HttpError Octokit access_token and client_secret headers redact all sensitive information.
+ * @param {Octokit} octokit The authenticated octokit instance, instantiated with an access token having permissiong to create a fork on the target repository
+ * @param {Changes | null | undefined} changes A set of changes. The changes may be empty
+ * @param {CreatePullRequestUserOptions} options The configuration for interacting with GitHub provided by the user.
+ * @returns {Promise<number>} the pull request number. Returns 0 if unsuccessful.
+ * @throws {CommitError} on failure during commit process
+ */
+async function createPullRequest(octokit, changes, options) {
+    (0, logger_1.setupLogger)(options.logger);
+    // if null undefined, or the empty map then no changes have been provided.
+    // Do not execute GitHub workflow
+    if (changes === null || changes === undefined || changes.size === 0) {
+        logger_1.logger.info('Empty change set provided. No changes need to be made. Cancelling workflow.');
+        return 0;
+    }
+    const gitHubConfigs = (0, default_options_handler_1.addPullRequestDefaults)(options);
+    logger_1.logger.info('Starting GitHub PR workflow...');
+    const upstream = {
+        owner: gitHubConfigs.upstreamOwner,
+        repo: gitHubConfigs.upstreamRepo,
+    };
+    const origin = options.fork === false ? upstream : await (0, fork_1.fork)(octokit, upstream);
+    if (options.fork) {
+        // try to sync the fork
+        await retry(async () => await octokit.repos.mergeUpstream({
+            owner: origin.owner,
+            repo: origin.repo,
+            branch: gitHubConfigs.primary,
+        }), {
+            retries: options.retry,
+            factor: 2.8411,
+            minTimeout: 3000,
+            randomize: false,
+            onRetry: (e, attempt) => {
+                e.message = `Error creating syncing upstream: ${e.message}`;
+                logger_1.logger.error(e);
+                logger_1.logger.info(`Retry attempt #${attempt}...`);
+            },
+        });
+    }
+    const originBranch = {
+        ...origin,
+        branch: gitHubConfigs.branch,
+    };
+    // The `retry` flag defaults to `5` to maintain compatibility
+    options.retry = options.retry === undefined ? 5 : options.retry;
+    const refHeadSha = await retry(async () => await (0, branch_1.branch)(octokit, origin, upstream, originBranch.branch, gitHubConfigs.primary), {
+        retries: options.retry,
+        factor: 2.8411,
+        minTimeout: 3000,
+        randomize: false,
+        onRetry: (e, attempt) => {
+            e.message = `Error creating Pull Request: ${e.message}`;
+            logger_1.logger.error(e);
+            logger_1.logger.info(`Retry attempt #${attempt}...`);
+        },
+    });
+    await (0, commit_and_push_1.commitAndPush)(octokit, refHeadSha, changes, originBranch, gitHubConfigs.message, gitHubConfigs.force, options);
+    const description = {
+        body: gitHubConfigs.description,
+        title: gitHubConfigs.title,
+    };
+    const prNumber = await (0, open_pull_request_1.openPullRequest)(octokit, upstream, originBranch, description, gitHubConfigs.maintainersCanModify, gitHubConfigs.primary, options.draft);
+    logger_1.logger.info(`Successfully opened pull request: ${prNumber}.`);
+    // addLabels will no-op if options.labels is undefined or empty.
+    await (0, labels_1.addLabels)(octokit, upstream, originBranch, prNumber, options.labels);
+    return prNumber;
+}
+exports.createPullRequest = createPullRequest;
+//# sourceMappingURL=index.js.map

package/build/src/util/code-suggester/logger.d.ts

@@ -0,0 +1,4 @@
+import { Logger } from './types';
+declare let logger: Logger;
+declare function setupLogger(userLogger?: Logger): void;
+export { logger, setupLogger };

package/build/src/util/code-suggester/logger.js

@@ -0,0 +1,37 @@
+"use strict";
+// Copyright 2026 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupLogger = exports.logger = void 0;
+class NullLogger {
+    constructor() {
+        this.error = () => { };
+        this.warn = () => { };
+        this.info = () => { };
+        this.debug = () => { };
+        this.trace = () => { };
+    }
+}
+let logger = new NullLogger();
+exports.logger = logger;
+function setupLogger(userLogger) {
+    if (userLogger) {
+        exports.logger = logger = userLogger;
+    }
+    else {
+        exports.logger = logger = new NullLogger();
+    }
+}
+exports.setupLogger = setupLogger;
+//# sourceMappingURL=logger.js.map

package/build/src/util/code-suggester/types.d.ts

@@ -0,0 +1,109 @@
+import { CreateCommitOptions } from './github/create-commit';
+export type FileMode = '100644' | '100755' | '040000' | '160000' | '120000';
+/**
+ * GitHub definition of tree
+ */
+export interface TreeObject {
+    path: string;
+    mode: FileMode;
+    type: 'blob' | 'tree' | 'commit';
+    sha?: string | null;
+    content?: string;
+}
+/**
+ * The content and the mode of a file.
+ * Default file mode is a text file which has code '100644'.
+ * If `content` is not null, then `content` must be the entire file content.
+ * See https://developer.github.com/v3/git/trees/#tree-object for details on mode.
+ */
+export declare class FileData {
+    readonly mode: FileMode;
+    readonly content: string | null;
+    constructor(content: string | null, mode?: FileMode);
+}
+/**
+ * The map of a path to its content data.
+ * The content must be the entire file content.
+ */
+export type Changes = Map<string, FileData>;
+/**
+ * The domain of a repository
+ */
+export interface RepoDomain {
+    repo: string;
+    owner: string;
+}
+/**
+ * The domain for a branch
+ */
+export interface BranchDomain extends RepoDomain {
+    branch: string;
+}
+/**
+ * The descriptive properties for any entity
+ */
+export interface Description {
+    title: string;
+    body: string;
+}
+/**
+ * The user options for creating GitHub PRs
+ */
+export interface CreatePullRequestUserOptions extends CreateCommitOptions {
+    upstreamOwner: string;
+    upstreamRepo: string;
+    message: string;
+    description: string;
+    title: string;
+    branch?: string;
+    force?: boolean;
+    fork?: boolean;
+    primary?: string;
+    maintainersCanModify?: boolean;
+    labels?: string[];
+    retry?: number;
+    draft?: boolean;
+    logger?: Logger;
+    filesPerCommit?: number;
+}
+/**
+ * GitHub data needed for creating a PR
+ */
+export interface CreatePullRequest {
+    upstreamOwner: string;
+    upstreamRepo: string;
+    message: string;
+    description: string;
+    title: string;
+    branch: string;
+    force: boolean;
+    primary: string;
+    maintainersCanModify: boolean;
+    filesPerCommit?: number;
+}
+interface LogFn {
+    <T extends object>(obj: T, msg?: string, ...args: any[]): void;
+    (msg: string, ...args: any[]): void;
+}
+export interface Logger {
+    error: LogFn;
+    warn: LogFn;
+    info: LogFn;
+    debug: LogFn;
+    trace: LogFn;
+}
+export interface UserData {
+    name: string;
+    email: string;
+}
+export interface CommitData {
+    message: string;
+    tree: string;
+    parents: string[];
+    author?: UserData;
+    committer?: UserData;
+}
+export interface CommitSigner {
+    generateSignature(commit: CommitData): Promise<string>;
+}
+export {};

package/build/src/util/code-suggester/types.js

@@ -0,0 +1,30 @@
+"use strict";
+// Copyright 2026 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileData = void 0;
+/**
+ * The content and the mode of a file.
+ * Default file mode is a text file which has code '100644'.
+ * If `content` is not null, then `content` must be the entire file content.
+ * See https://developer.github.com/v3/git/trees/#tree-object for details on mode.
+ */
+class FileData {
+    constructor(content, mode = '100644') {
+        this.mode = mode;
+        this.content = content;
+    }
+}
+exports.FileData = FileData;
+//# sourceMappingURL=types.js.map

package/build/src/util/pull-request-title.js

@@ -32,10 +32,10 @@ function generateMatchPattern(pullRequestTitlePattern, componentNoSpace, logger
         pullRequestTitlePattern.search(/\$\{version\}/) === -1)
         logger.warn("pullRequestTitlePattern miss the part of '${version}'");
     return new RegExp(`^${(pullRequestTitlePattern || DEFAULT_PR_TITLE_PATTERN)
-        .replace('[', '\\[') // TODO: handle all regex escaping
-        .replace(']', '\\]')
-        .replace('(', '\\(')
-        .replace(')', '\\)')
+        .replace(/\[/g, '\\[') // TODO: handle all regex escaping
+        .replace(/\]/g, '\\]')
+        .replace(/\(/g, '\\(')
+        .replace(/\)/g, '\\)')
         .replace('${scope}', '(\\((?<branch>[\\w-./]+)\\))?')
         .replace('${component}', componentNoSpace === true
         ? '?(?<component>@?[\\w-./]*)?'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "release-please",
-  "version": "17.8.0",
+  "version": "17.9.0",
   "description": "generate release PRs based on the conventionalcommits.org spec",
   "main": "./build/src/index.js",
   "bin": "./build/src/bin/release-please.js",
@@ -39,6 +39,7 @@
   },
   "devDependencies": {
     "@octokit/types": "^9.0.0",
+    "@types/async-retry": "^1.4.9",
     "@types/chai": "^4.1.7",
     "@types/diff": "^5.0.2",
     "@types/iarna__toml": "^2.0.1",
@@ -75,8 +76,8 @@
     "@octokit/rest": "^20.1.1",
     "@types/npm-package-arg": "^6.1.0",
     "@xmldom/xmldom": "^0.8.4",
+    "async-retry": "^1.3.3",
     "chalk": "^4.0.0",
-    "code-suggester": "^5.0.0",
     "conventional-changelog-conventionalcommits": "^6.0.0",
     "conventional-changelog-writer": "^6.0.0",
     "conventional-commits-filter": "^3.0.0",