@aspruyt/xfg 6.0.3 → 6.2.0

package/dist/vcs/ado-pr-strategy.js

@@ -1,6 +1,5 @@
 import { existsSync, writeFileSync, unlinkSync } from "node:fs";
 import { join } from "node:path";
-import { escapeShellArg } from "../shared/shell-utils.js";
 import { assertAzureDevOpsRepo, } from "../repo/index.js";
 import { SyncError } from "../shared/errors.js";
 import { BasePRStrategy } from "./pr-strategy.js";
@@ -8,13 +7,10 @@ import { withRetry, isPermanentError } from "../shared/retry-utils.js";
 import { toErrorMessage } from "../shared/type-guards.js";
 import { safeCleanup } from "../shared/cleanup-utils.js";
 import { NO_OP_DEBUG_LOG } from "../shared/logger.js";
-import { sanitizeCredentials } from "./sanitize-utils.js";
+import { sanitizeCredentials } from "../shared/sanitize-utils.js";
 import { getStderr } from "../shared/command-executor.js";
 export class AdoPRStrategy extends BasePRStrategy {
-    constructor(executor, log) {
-        super(executor, log);
-        this.bodyFilePath = ".pr-description.md";
-    }
+    bodyFilePath = ".pr-description.md";
     getOrgUrl(repoInfo) {
         return `https://dev.azure.com/${encodeURIComponent(repoInfo.organization)}`;
     }
@@ -27,9 +23,27 @@ export class AdoPRStrategy extends BasePRStrategy {
      */
     async findExistingPRId(azureRepoInfo, branchName, baseBranch, workDir, retries) {
         const orgUrl = this.getOrgUrl(azureRepoInfo);
-        const command = `az repos pr list --repository ${escapeShellArg(azureRepoInfo.repo)} --source-branch ${escapeShellArg(branchName)} --target-branch ${escapeShellArg(baseBranch)} --org ${escapeShellArg(orgUrl)} --project ${escapeShellArg(azureRepoInfo.project)} --query "[0].pullRequestId" -o tsv`;
+        const args = [
+            "repos",
+            "pr",
+            "list",
+            "--repository",
+            azureRepoInfo.repo,
+            "--source-branch",
+            branchName,
+            "--target-branch",
+            baseBranch,
+            "--org",
+            orgUrl,
+            "--project",
+            azureRepoInfo.project,
+            "--query",
+            "[0].pullRequestId",
+            "-o",
+            "tsv",
+        ];
         try {
-            const existingPRId = await withRetry(() => this.executor.exec(command, workDir), { retries, log: this.log });
+            const existingPRId = await withRetry(() => this.executor.exec("az", args, workDir), { retries, log: this.log });
             return existingPRId ? existingPRId.trim() : null;
         }
         catch (error) {
@@ -57,12 +71,21 @@ export class AdoPRStrategy extends BasePRStrategy {
         const orgUrl = this.getOrgUrl(azureRepoInfo);
         const prId = await this.findExistingPRId(azureRepoInfo, branchName, baseBranch, workDir, retries);
         if (!prId) {
-            return false;
+            return { status: "no_pr" };
         }
-        // Abandon the PR (Azure DevOps equivalent of closing)
-        const abandonCommand = `az repos pr update --id ${escapeShellArg(prId)} --status abandoned --org ${escapeShellArg(orgUrl)}`;
+        const abandonArgs = [
+            "repos",
+            "pr",
+            "update",
+            "--id",
+            prId,
+            "--status",
+            "abandoned",
+            "--org",
+            orgUrl,
+        ];
         try {
-            await withRetry(() => this.executor.exec(abandonCommand, workDir), {
+            await withRetry(() => this.executor.exec("az", abandonArgs, workDir), {
                 retries,
                 log: this.log,
             });
@@ -70,22 +93,52 @@ export class AdoPRStrategy extends BasePRStrategy {
         catch (error) {
             const message = toErrorMessage(error);
             this.log?.warn(`Failed to abandon PR #${prId}: ${message}`);
-            return false;
+            return { status: "close_failed", message };
         }
         try {
-            const getRefCommand = `az repos ref list --repository ${escapeShellArg(azureRepoInfo.repo)} --org ${escapeShellArg(orgUrl)} --project ${escapeShellArg(azureRepoInfo.project)} --filter heads/${escapeShellArg(branchName)} --query "[0].objectId" -o tsv`;
-            const objectId = await withRetry(() => this.executor.exec(getRefCommand, workDir), { retries, log: this.log });
+            const getRefArgs = [
+                "repos",
+                "ref",
+                "list",
+                "--repository",
+                azureRepoInfo.repo,
+                "--org",
+                orgUrl,
+                "--project",
+                azureRepoInfo.project,
+                "--filter",
+                `heads/${branchName}`,
+                "--query",
+                "[0].objectId",
+                "-o",
+                "tsv",
+            ];
+            const objectId = await withRetry(() => this.executor.exec("az", getRefArgs, workDir), { retries, log: this.log });
             if (objectId) {
-                const deleteBranchCommand = `az repos ref delete --name refs/heads/${escapeShellArg(branchName)} --repository ${escapeShellArg(azureRepoInfo.repo)} --org ${escapeShellArg(orgUrl)} --project ${escapeShellArg(azureRepoInfo.project)} --object-id ${escapeShellArg(objectId)}`;
-                await withRetry(() => this.executor.exec(deleteBranchCommand, workDir), { retries, log: this.log });
+                const deleteBranchArgs = [
+                    "repos",
+                    "ref",
+                    "delete",
+                    "--name",
+                    `refs/heads/${branchName}`,
+                    "--repository",
+                    azureRepoInfo.repo,
+                    "--org",
+                    orgUrl,
+                    "--project",
+                    azureRepoInfo.project,
+                    "--object-id",
+                    objectId,
+                ];
+                await withRetry(() => this.executor.exec("az", deleteBranchArgs, workDir), { retries, log: this.log });
             }
         }
         catch (error) {
-            // Branch deletion failure is not critical - PR is already abandoned
-            const message = toErrorMessage(error);
-            this.log?.warn(`Failed to delete branch ${branchName}: ${message}`);
+            const message = `PR #${prId} abandoned but branch ${branchName} deletion failed: ${toErrorMessage(error)}`;
+            this.log?.warn(message);
+            return { status: "close_failed", message };
         }
-        return true;
+        return { status: "closed" };
     }
     async create(options) {
         const { repoInfo, title, body, branchName, baseBranch, workDir, retries = 3, } = options;
@@ -97,12 +150,33 @@ export class AdoPRStrategy extends BasePRStrategy {
             writeFileSync(descFile, body, "utf-8");
         }
         catch (err) {
-            throw new SyncError(`Failed to write PR description to ${descFile}: ${toErrorMessage(err)}`);
+            throw new SyncError(`Failed to write PR description to ${descFile}: ${toErrorMessage(err)}`, { cause: err });
         }
-        // Azure CLI @file syntax: escape the full @path to handle special chars in workDir
-        const command = `az repos pr create --repository ${escapeShellArg(azureRepoInfo.repo)} --source-branch ${escapeShellArg(branchName)} --target-branch ${escapeShellArg(baseBranch)} --title ${escapeShellArg(title)} --description ${escapeShellArg("@" + descFile)} --org ${escapeShellArg(orgUrl)} --project ${escapeShellArg(azureRepoInfo.project)} --query "pullRequestId" -o tsv`;
+        const args = [
+            "repos",
+            "pr",
+            "create",
+            "--repository",
+            azureRepoInfo.repo,
+            "--source-branch",
+            branchName,
+            "--target-branch",
+            baseBranch,
+            "--title",
+            title,
+            "--description",
+            `@${descFile}`,
+            "--org",
+            orgUrl,
+            "--project",
+            azureRepoInfo.project,
+            "--query",
+            "pullRequestId",
+            "-o",
+            "tsv",
+        ];
         try {
-            const prId = await withRetry(() => this.executor.exec(command, workDir), {
+            const prId = await withRetry(() => this.executor.exec("az", args, workDir), {
                 retries,
                 log: this.log,
             });
@@ -152,13 +226,21 @@ export class AdoPRStrategy extends BasePRStrategy {
             };
         }
         const orgUrl = `https://dev.azure.com/${encodeURIComponent(prInfo.organization)}`;
-        const squashFlag = config.strategy === "squash" ? "--squash true" : "";
-        const deleteBranchFlag = config.deleteBranch
-            ? "--delete-source-branch true"
-            : "";
         if (config.mode === "auto") {
-            const autoCommand = `az repos pr update --id ${escapeShellArg(prInfo.prId)} --auto-complete true ${squashFlag} ${deleteBranchFlag} --org ${escapeShellArg(orgUrl)}`.trim();
-            return this.executeMergeCommand(() => this.executor.exec(autoCommand, workDir), retries, {
+            const autoArgs = [
+                "repos",
+                "pr",
+                "update",
+                "--id",
+                prInfo.prId,
+                "--auto-complete",
+                "true",
+                ...(config.strategy === "squash" ? ["--squash", "true"] : []),
+                ...(config.deleteBranch ? ["--delete-source-branch", "true"] : []),
+                "--org",
+                orgUrl,
+            ];
+            return this.executeMergeCommand(() => this.executor.exec("az", autoArgs, workDir), retries, {
                 success: true,
                 message: "Auto-complete enabled. PR will merge when all policies pass.",
                 merged: false,
@@ -168,8 +250,24 @@ export class AdoPRStrategy extends BasePRStrategy {
         if (config.mode === "force") {
             const bypassReason = config.bypassReason ?? "Automated config sync via xfg";
             this.log?.warn(`Bypassing policies for PR ${prInfo.prId} (reason: ${bypassReason})`);
-            const forceCommand = `az repos pr update --id ${escapeShellArg(prInfo.prId)} --bypass-policy true --bypass-policy-reason ${escapeShellArg(bypassReason)} --status completed ${squashFlag} ${deleteBranchFlag} --org ${escapeShellArg(orgUrl)}`.trim();
-            return this.executeMergeCommand(() => this.executor.exec(forceCommand, workDir), retries, {
+            const forceArgs = [
+                "repos",
+                "pr",
+                "update",
+                "--id",
+                prInfo.prId,
+                "--bypass-policy",
+                "true",
+                "--bypass-policy-reason",
+                bypassReason,
+                "--status",
+                "completed",
+                ...(config.strategy === "squash" ? ["--squash", "true"] : []),
+                ...(config.deleteBranch ? ["--delete-source-branch", "true"] : []),
+                "--org",
+                orgUrl,
+            ];
+            return this.executeMergeCommand(() => this.executor.exec("az", forceArgs, workDir), retries, {
                 success: true,
                 message: "PR completed by bypassing policies.",
                 merged: true,

package/dist/vcs/authenticated-git-ops.js

@@ -1,4 +1,3 @@
-import { escapeShellArg } from "../shared/shell-utils.js";
 import { withRetry } from "../shared/retry-utils.js";
 import { toErrorMessage } from "../shared/type-guards.js";
 import { SyncError } from "../shared/errors.js";
@@ -17,8 +16,8 @@ export class AuthenticatedGitOps {
         this.auth = options.auth;
         this.log = options.log;
     }
-    execWithRetry(command) {
-        return withRetry(() => this.executor.exec(command, this.workDir), {
+    execWithRetry(executable, args) {
+        return withRetry(() => this.executor.exec(executable, args, this.workDir), {
             retries: this.retries,
         });
     }
@@ -85,28 +84,43 @@ export class AuthenticatedGitOps {
         return this.localOps.getDefaultBranchLocal();
     }
     // --- INetworkGitOps with auth wrapping ---
-    // Note: exec() usage here is safe — all user inputs are escaped via escapeShellArg()
     async clone(gitUrl) {
         if (!this.auth) {
-            const command = `git clone ${escapeShellArg(gitUrl)} .`;
-            await this.execWithRetry(command);
+            await this.execWithRetry("git", ["clone", "--", gitUrl, "."]);
             return;
         }
-        const authUrl = escapeShellArg(this.getAuthenticatedUrl());
-        await this.execWithRetry(`git clone ${authUrl} .`);
+        await this.execWithRetry("git", [
+            "clone",
+            "--",
+            this.getAuthenticatedUrl(),
+            ".",
+        ]);
     }
     async fetch(options) {
-        const pruneFlag = options?.prune ? " --prune" : "";
-        await this.execWithRetry(`git fetch origin${pruneFlag}`);
+        await this.execWithRetry("git", [
+            "fetch",
+            "origin",
+            ...(options?.prune ? ["--prune"] : []),
+        ]);
     }
     async push(branchName, options) {
-        const forceFlag = options?.force ? "--force-with-lease " : "";
-        const safeBranch = escapeShellArg(branchName);
-        await this.execWithRetry(`git push ${forceFlag}-u origin ${safeBranch}`);
+        const args = [
+            "push",
+            ...(options?.force ? ["--force-with-lease"] : []),
+            "-u",
+            "origin",
+            "--",
+            branchName,
+        ];
+        await this.execWithRetry("git", args);
     }
     async getDefaultBranch() {
         try {
-            const remoteInfo = await this.execWithRetry(`git remote show origin`);
+            const remoteInfo = await this.execWithRetry("git", [
+                "remote",
+                "show",
+                "origin",
+            ]);
             const match = remoteInfo.match(/HEAD branch: (\S+)/);
             if (match && match[1] !== "(unknown)") {
                 return { branch: match[1], method: "remote HEAD" };
@@ -127,28 +141,36 @@ export class AuthenticatedGitOps {
      *   branch existence where failure is expected for new branches.
      */
     lsRemote(branchName, options) {
-        const safeBranch = escapeShellArg(branchName);
-        const command = `git ls-remote --exit-code --heads origin ${safeBranch}`;
+        const args = ["ls-remote", "--exit-code", "--heads", "origin", branchName];
         if (options?.skipRetry) {
-            return this.executor.exec(command, this.workDir);
+            return this.executor.exec("git", args, this.workDir);
         }
-        return this.execWithRetry(command);
+        return this.execWithRetry("git", args);
     }
     /**
      * Execute push with custom refspec (e.g., HEAD:branchName).
      * Used by GraphQLCommitStrategy for creating/deleting remote branches.
      */
     async pushRefspec(refspec, options) {
-        const deleteFlag = options?.delete ? "--delete " : "";
-        const safeRefspec = escapeShellArg(refspec);
-        await this.execWithRetry(`git push ${deleteFlag}-u origin ${safeRefspec}`);
+        const args = [
+            "push",
+            ...(options?.delete ? ["--delete"] : []),
+            "-u",
+            "origin",
+            "--",
+            refspec,
+        ];
+        await this.execWithRetry("git", args);
     }
     /**
      * Fetch a specific branch from remote.
      * Used by GraphQLCommitStrategy to update local refs.
      */
     async fetchBranch(branchName) {
-        const safeBranch = escapeShellArg(branchName);
-        await this.execWithRetry(`git fetch origin +${safeBranch}:refs/remotes/origin/${safeBranch}`);
+        await this.execWithRetry("git", [
+            "fetch",
+            "origin",
+            `+${branchName}:refs/remotes/origin/${branchName}`,
+        ]);
     }
 }

package/dist/vcs/git-commit-strategy.js

@@ -1,5 +1,4 @@
 import { withRetry } from "../shared/retry-utils.js";
-import { escapeShellArg } from "../shared/shell-utils.js";
 /**
  * Git-based commit strategy using standard git commands (add, commit, push).
  * Used with PAT authentication. Commits via this strategy are NOT verified
@@ -20,20 +19,25 @@ export class GitCommitStrategy {
         const { branchName, message, workDir, retries = 3, force = true, gitOps, } = options;
         // Commit with the message (--no-verify to skip pre-commit hooks)
         // Staging is handled by CommitPushManager before calling commit()
-        await this.executor.exec(`git commit --no-verify -m ${escapeShellArg(message)}`, workDir);
+        await this.executor.exec("git", ["commit", "--no-verify", "-m", message], workDir);
         // Push with authentication via gitOps if available
         if (gitOps) {
             await gitOps.push(branchName, { force });
         }
         else {
             // Fallback for non-authenticated scenarios (shouldn't happen in practice)
-            const forceFlag = force ? "--force-with-lease " : "";
-            const pushCommand = `git push ${forceFlag}-u origin ${escapeShellArg(branchName)}`;
-            await withRetry(() => this.executor.exec(pushCommand, workDir), {
+            const args = [
+                "push",
+                ...(force ? ["--force-with-lease"] : []),
+                "-u",
+                "origin",
+                branchName,
+            ];
+            await withRetry(() => this.executor.exec("git", args, workDir), {
                 retries,
             });
         }
-        const sha = await this.executor.exec("git rev-parse HEAD", workDir);
+        const sha = await this.executor.exec("git", ["rev-parse", "HEAD"], workDir);
         return {
             sha: sha.trim(),
             verified: false, // Git-based commits are not verified

package/dist/vcs/git-ops.js

@@ -1,6 +1,5 @@
 import { rmSync, existsSync, statSync, mkdirSync, writeFileSync, readFileSync, chmodSync, } from "node:fs";
 import { join, resolve, relative, isAbsolute, dirname } from "node:path";
-import { escapeShellArg } from "../shared/shell-utils.js";
 import { toErrorMessage } from "../shared/type-guards.js";
 import { ValidationError, SyncError } from "../shared/errors.js";
 export class GitOps {
@@ -14,8 +13,8 @@ export class GitOps {
         this.executor = options.executor;
         this.log = options.log;
     }
-    exec(command, cwd) {
-        return this.executor.exec(command, cwd ?? this.workDir);
+    exec(executable, args, cwd) {
+        return this.executor.exec(executable, args, cwd ?? this.workDir);
     }
     /**
      * Validates that a file path doesn't escape the workspace directory.
@@ -40,7 +39,7 @@ export class GitOps {
             mkdirSync(this.workDir, { recursive: true });
         }
         catch (error) {
-            throw new SyncError(`Failed to clean workspace '${this.workDir}': ${toErrorMessage(error)}`);
+            throw new SyncError(`Failed to clean workspace '${this.workDir}': ${toErrorMessage(error)}`, { cause: error });
         }
     }
     /**
@@ -50,11 +49,11 @@ export class GitOps {
      */
     async createBranch(branchName) {
         try {
-            await this.exec(`git checkout -b ${escapeShellArg(branchName)}`, this.workDir);
+            await this.exec("git", ["checkout", "-b", branchName]);
         }
         catch (error) {
             const message = toErrorMessage(error);
-            throw new SyncError(`Failed to create branch '${branchName}': ${message}`);
+            throw new SyncError(`Failed to create branch '${branchName}': ${message}`, { cause: error });
         }
     }
     writeFile(fileName, content) {
@@ -68,7 +67,7 @@ export class GitOps {
             writeFileSync(filePath, normalized, "utf-8");
         }
         catch (error) {
-            throw new SyncError(`Failed to write file '${fileName}': ${toErrorMessage(error)}`);
+            throw new SyncError(`Failed to write file '${fileName}': ${toErrorMessage(error)}`, { cause: error });
         }
     }
     /**
@@ -86,11 +85,16 @@ export class GitOps {
             chmodSync(filePath, 0o755);
         }
         catch (error) {
-            throw new SyncError(`Failed to set executable permissions on '${fileName}': ${toErrorMessage(error)}`);
+            throw new SyncError(`Failed to set executable permissions on '${fileName}': ${toErrorMessage(error)}`, { cause: error });
         }
-        // Also update git's index so the executable bit is committed
         const relativePath = relative(this.workDir, filePath);
-        await this.exec(`git update-index --add --chmod=+x ${escapeShellArg(relativePath)}`, this.workDir);
+        await this.exec("git", [
+            "update-index",
+            "--add",
+            "--chmod=+x",
+            "--",
+            relativePath,
+        ]);
     }
     /**
      * Clears the executable bit on a file both on the filesystem and in git's index.
@@ -105,9 +109,9 @@ export class GitOps {
             chmodSync(filePath, 0o644);
         }
         catch (error) {
-            throw new SyncError(`Failed to clear executable permissions on '${fileName}': ${toErrorMessage(error)}`);
+            throw new SyncError(`Failed to clear executable permissions on '${fileName}': ${toErrorMessage(error)}`, { cause: error });
         }
-        await this.exec(`git update-index --chmod=-x -- ${escapeShellArg(fileName)}`, this.workDir);
+        await this.exec("git", ["update-index", "--chmod=-x", "--", fileName]);
     }
     /**
      * Returns the git index mode for a tracked file ("100755" or "100644"),
@@ -116,7 +120,7 @@ export class GitOps {
      */
     async getFileMode(fileName) {
         this.validatePath(fileName);
-        const output = await this.exec(`git ls-files -s -- ${escapeShellArg(fileName)}`, this.workDir);
+        const output = await this.exec("git", ["ls-files", "-s", "--", fileName]);
         const line = output.trim();
         if (!line)
             return null;
@@ -171,7 +175,7 @@ export class GitOps {
         }
     }
     async hasChanges() {
-        const status = await this.exec("git status --porcelain", this.workDir);
+        const status = await this.exec("git", ["status", "--porcelain"]);
         return status.length > 0;
     }
     /**
@@ -179,7 +183,7 @@ export class GitOps {
      * Returns relative file paths for files that are modified, added, or untracked.
      */
     async getChangedFiles() {
-        const status = await this.exec("git status --porcelain", this.workDir);
+        const status = await this.exec("git", ["status", "--porcelain"]);
         if (!status)
             return [];
         return status
@@ -188,10 +192,10 @@ export class GitOps {
             .map((line) => line.slice(3)); // Remove status prefix (e.g., " M ", "?? ", "A  ")
     }
     async stageAll() {
-        await this.exec("git add -A", this.workDir);
+        await this.exec("git", ["add", "-A"]);
     }
     async hasStagedChanges() {
-        const diff = await this.exec("git diff --cached --name-only", this.workDir);
+        const diff = await this.exec("git", ["diff", "--cached", "--name-only"]);
         return diff.length > 0;
     }
     /**
@@ -199,8 +203,11 @@ export class GitOps {
      * Used for createOnly checks against the base branch (not the working directory).
      */
     async fileExistsOnBranch(fileName, branch) {
+        if (branch.startsWith("-")) {
+            throw new ValidationError(`Branch name '${branch}' is not supported: branch names starting with '-' can be misinterpreted as git flags`);
+        }
         try {
-            await this.exec(`git show ${escapeShellArg(branch)}:${escapeShellArg(fileName)}`, this.workDir);
+            await this.exec("git", ["show", `${branch}:${fileName}`]);
             return true;
         }
         catch (error) {
@@ -236,7 +243,7 @@ export class GitOps {
             rmSync(filePath);
         }
         catch (error) {
-            throw new SyncError(`Failed to delete file '${fileName}': ${toErrorMessage(error)}`);
+            throw new SyncError(`Failed to delete file '${fileName}': ${toErrorMessage(error)}`, { cause: error });
         }
     }
     /**
@@ -248,13 +255,12 @@ export class GitOps {
         if (this.dryRun) {
             return true;
         }
-        await this.exec("git add -A", this.workDir);
+        await this.exec("git", ["add", "-A"]);
         // Check if there are actually staged changes after git add
         if (!(await this.hasStagedChanges())) {
             return false; // No changes to commit
         }
-        // Use --no-verify to skip pre-commit hooks
-        await this.exec(`git commit --no-verify -m ${escapeShellArg(message)}`, this.workDir);
+        await this.exec("git", ["commit", "--no-verify", "-m", message]);
         return true;
     }
     /**
@@ -263,7 +269,7 @@ export class GitOps {
      */
     async getDefaultBranchLocal() {
         try {
-            await this.exec("git rev-parse --verify origin/main", this.workDir);
+            await this.exec("git", ["rev-parse", "--verify", "origin/main"]);
             return { branch: "main", method: "origin/main exists" };
         }
         catch (error) {
@@ -271,7 +277,7 @@ export class GitOps {
             this.log?.debug(`origin/main check failed - ${msg}`);
         }
         try {
-            await this.exec("git rev-parse --verify origin/master", this.workDir);
+            await this.exec("git", ["rev-parse", "--verify", "origin/master"]);
             return { branch: "master", method: "origin/master exists" };
         }
         catch (error) {

package/dist/vcs/github-pr-strategy.d.ts

@@ -1,9 +1,10 @@
 import type { PRResult } from "./types.js";
 import { BasePRStrategy } from "./pr-strategy.js";
-import type { PRStrategyOptions, CloseExistingPROptions, MergeOptions, MergeResult } from "./types.js";
+import type { PRStrategyOptions, CloseExistingPROptions, ClosePRResult, MergeOptions, MergeResult } from "./types.js";
 export declare class GitHubPRStrategy extends BasePRStrategy {
+    private readonly bodyFilePath;
     findExistingPRUrl(options: CloseExistingPROptions): Promise<string | null>;
-    closeExistingPR(options: CloseExistingPROptions): Promise<boolean>;
+    closeExistingPR(options: CloseExistingPROptions): Promise<ClosePRResult>;
     create(options: PRStrategyOptions): Promise<PRResult>;
     /**
      * Check if auto-merge is enabled on the repository.