release-please 17.7.0 → 17.9.0

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 };