@aspruyt/xfg 4.0.0 → 4.0.1

package/dist/vcs/git-ops.js

@@ -2,30 +2,20 @@ import { rmSync, existsSync, mkdirSync, writeFileSync, readFileSync, chmodSync,
 import { join, resolve, relative, isAbsolute, dirname } from "node:path";
 import { escapeShellArg } from "../shared/shell-utils.js";
 import { defaultExecutor, } from "../shared/command-executor.js";
-import { withRetry } from "../shared/retry-utils.js";
-import { logger } from "../shared/logger.js";
+import { toErrorMessage } from "../shared/type-guards.js";
 export class GitOps {
-    workDir;
+    _workDir;
     dryRun;
-    executor;
-    retries;
+    _executor;
+    log;
     constructor(options) {
-        this.workDir = options.workDir;
+        this._workDir = options.workDir;
         this.dryRun = options.dryRun ?? false;
-        this.executor = options.executor ?? defaultExecutor;
-        this.retries = options.retries ?? 3;
+        this._executor = options.executor ?? defaultExecutor;
+        this.log = options.log;
     }
     async exec(command, cwd) {
-        return this.executor.exec(command, cwd ?? this.workDir);
-    }
-    /**
-     * Run a command with retry logic for transient failures.
-     * Used for network operations like clone, fetch, push.
-     */
-    async execWithRetry(command, cwd) {
-        return withRetry(() => this.exec(command, cwd), {
-            retries: this.retries,
-        });
+        return this._executor.exec(command, cwd ?? this._workDir);
     }
     /**
      * Validates that a file path doesn't escape the workspace directory.
@@ -33,9 +23,9 @@ export class GitOps {
      * @throws Error if path traversal is detected
      */
     validatePath(fileName) {
-        const filePath = join(this.workDir, fileName);
+        const filePath = join(this._workDir, fileName);
         const resolvedPath = resolve(filePath);
-        const resolvedWorkDir = resolve(this.workDir);
+        const resolvedWorkDir = resolve(this._workDir);
         const relativePath = relative(resolvedWorkDir, resolvedPath);
         if (relativePath.startsWith("..") || isAbsolute(relativePath)) {
             throw new Error(`Path traversal detected: ${fileName}`);
@@ -43,21 +33,10 @@ export class GitOps {
         return filePath;
     }
     cleanWorkspace() {
-        if (existsSync(this.workDir)) {
-            rmSync(this.workDir, { recursive: true, force: true });
+        if (existsSync(this._workDir)) {
+            rmSync(this._workDir, { recursive: true, force: true });
         }
-        mkdirSync(this.workDir, { recursive: true });
-    }
-    async clone(gitUrl) {
-        await this.execWithRetry(`git clone ${escapeShellArg(gitUrl)} .`, this.workDir);
-    }
-    /**
-     * Fetch from remote with optional pruning of stale refs.
-     * Used to update local tracking refs after remote branch deletion.
-     */
-    async fetch(options) {
-        const pruneFlag = options?.prune ? " --prune" : "";
-        await this.execWithRetry(`git fetch origin${pruneFlag}`, this.workDir);
+        mkdirSync(this._workDir, { recursive: true });
     }
     /**
      * Create a new branch from the current HEAD.
@@ -66,10 +45,10 @@ export class GitOps {
      */
     async createBranch(branchName) {
         try {
-            await this.exec(`git checkout -b ${escapeShellArg(branchName)}`, this.workDir);
+            await this.exec(`git checkout -b ${escapeShellArg(branchName)}`, this._workDir);
         }
         catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
+            const message = toErrorMessage(error);
             throw new Error(`Failed to create branch '${branchName}': ${message}`);
         }
     }
@@ -98,8 +77,8 @@ export class GitOps {
         // Set filesystem permissions (755 = rwxr-xr-x)
         chmodSync(filePath, 0o755);
         // 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);
+        const relativePath = relative(this._workDir, filePath);
+        await this.exec(`git update-index --add --chmod=+x ${escapeShellArg(relativePath)}`, this._workDir);
     }
     /**
      * Get the content of a file in the workspace.
@@ -113,7 +92,8 @@ export class GitOps {
         try {
             return readFileSync(filePath, "utf-8");
         }
-        catch {
+        catch (error) {
+            this.log?.debug(`Failed to read ${fileName}: ${toErrorMessage(error)}`);
             return null;
         }
     }
@@ -133,13 +113,13 @@ export class GitOps {
             const existingContent = readFileSync(filePath, "utf-8");
             return existingContent !== newContent;
         }
-        catch {
-            // If we can't read the file, assume it would change
+        catch (error) {
+            this.log?.debug(`Failed to read ${fileName} for comparison: ${toErrorMessage(error)}`);
             return true;
         }
     }
     async hasChanges() {
-        const status = await this.exec("git status --porcelain", this.workDir);
+        const status = await this.exec("git status --porcelain", this._workDir);
         return status.length > 0;
     }
     /**
@@ -148,7 +128,7 @@ export class GitOps {
      * Uses the same this.exec() pattern as other methods in this class.
      */
     async getChangedFiles() {
-        const status = await this.exec("git status --porcelain", this.workDir);
+        const status = await this.exec("git status --porcelain", this._workDir);
         if (!status)
             return [];
         return status
@@ -162,11 +142,13 @@ export class GitOps {
      */
     async hasStagedChanges() {
         try {
-            await this.exec("git diff --cached --quiet", this.workDir);
+            await this.exec("git diff --cached --quiet", this._workDir);
             return false; // Exit code 0 = no staged changes
         }
-        catch {
-            return true; // Exit code 1 = there are staged changes
+        catch (error) {
+            // Exit code 1 is expected when staged changes exist
+            this.log?.debug(`hasStagedChanges: ${toErrorMessage(error)}`);
+            return true;
         }
     }
     /**
@@ -175,16 +157,15 @@ export class GitOps {
      */
     async fileExistsOnBranch(fileName, branch) {
         try {
-            await this.exec(`git show ${escapeShellArg(branch)}:${escapeShellArg(fileName)}`, this.workDir);
+            await this.exec(`git show ${escapeShellArg(branch)}:${escapeShellArg(fileName)}`, this._workDir);
             return true;
         }
-        catch {
+        catch (error) {
+            // Expected when file doesn't exist on branch
+            this.log?.debug(`fileExistsOnBranch(${fileName}, ${branch}): ${toErrorMessage(error)}`);
             return false;
         }
     }
-    /**
-     * Check if a file exists in the working directory.
-     */
     fileExists(fileName) {
         const filePath = this.validatePath(fileName);
         return existsSync(filePath);
@@ -201,7 +182,7 @@ export class GitOps {
         }
         const filePath = this.validatePath(fileName);
         if (!existsSync(filePath)) {
-            return; // File doesn't exist, nothing to delete
+            return;
         }
         rmSync(filePath);
     }
@@ -214,81 +195,36 @@ export class GitOps {
         if (this.dryRun) {
             return true;
         }
-        await this.exec("git add -A", this.workDir);
+        await this.exec("git add -A", this._workDir);
         // 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 ${escapeShellArg(message)}`, this._workDir);
         return true;
     }
-    async push(branchName, options) {
-        if (this.dryRun) {
-            return;
-        }
-        const forceFlag = options?.force ? "--force-with-lease " : "";
-        await this.execWithRetry(`git push ${forceFlag}-u origin ${escapeShellArg(branchName)}`, this.workDir);
-    }
-    async getDefaultBranch() {
-        try {
-            // Try to get the default branch from remote (network operation with retry)
-            const remoteInfo = await this.execWithRetry("git remote show origin", this.workDir);
-            const match = remoteInfo.match(/HEAD branch: (\S+)/);
-            if (match && match[1] !== "(unknown)") {
-                return { branch: match[1], method: "remote HEAD" };
-            }
-        }
-        catch (error) {
-            const msg = error instanceof Error ? error.message : String(error);
-            logger.info(`Debug: git remote show origin failed - ${msg}`);
-        }
-        // Try common default branch names (local operations, no retry needed)
+    /**
+     * Fallback default branch detection using local refs only.
+     * Checks origin/main, then origin/master, then defaults to "main".
+     */
+    async getDefaultBranchLocal() {
         try {
-            await this.exec("git rev-parse --verify origin/main", this.workDir);
+            await this.exec("git rev-parse --verify origin/main", this._workDir);
             return { branch: "main", method: "origin/main exists" };
         }
         catch (error) {
-            const msg = error instanceof Error ? error.message : String(error);
-            logger.info(`Debug: origin/main check failed - ${msg}`);
+            const msg = toErrorMessage(error);
+            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", this._workDir);
             return { branch: "master", method: "origin/master exists" };
         }
         catch (error) {
-            const msg = error instanceof Error ? error.message : String(error);
-            logger.info(`Debug: origin/master check failed - ${msg}`);
+            const msg = toErrorMessage(error);
+            this.log?.debug(`origin/master check failed - ${msg}`);
         }
         return { branch: "main", method: "fallback default" };
     }
 }
-export function sanitizeBranchName(fileName) {
-    return fileName
-        .toLowerCase()
-        .replace(/\.[^.]+$/, "") // Remove extension
-        .replace(/[^a-z0-9-]/g, "-") // Replace non-alphanumeric with dashes
-        .replace(/-+/g, "-") // Collapse multiple dashes
-        .replace(/^-|-$/g, ""); // Remove leading/trailing dashes
-}
-/**
- * Validates a user-provided branch name against git's naming rules.
- * @throws Error if the branch name is invalid
- */
-export function validateBranchName(branchName) {
-    if (!branchName || branchName.trim() === "") {
-        throw new Error("Branch name cannot be empty");
-    }
-    if (branchName.startsWith(".") || branchName.startsWith("-")) {
-        throw new Error('Branch name cannot start with "." or "-"');
-    }
-    // Git disallows: space, ~, ^, :, ?, *, [, \, and consecutive dots (..)
-    if (/[\s~^:?*[\\]/.test(branchName) || branchName.includes("..")) {
-        throw new Error("Branch name contains invalid characters");
-    }
-    if (branchName.endsWith("/") ||
-        branchName.endsWith(".lock") ||
-        branchName.endsWith(".")) {
-        throw new Error("Branch name has invalid ending");
-    }
-}

package/dist/vcs/github-app-token-manager.d.ts

@@ -1,6 +1,4 @@
 import type { GitHubRepoInfo } from "../shared/repo-detector.js";
-/** Duration to cache tokens (45 minutes in milliseconds) */
-export declare const TOKEN_CACHE_DURATION_MS: number;
 /**
  * Manages GitHub App authentication tokens for multiple organizations.
  * Handles JWT generation, installation discovery, and token caching.
@@ -25,10 +23,6 @@ export declare class GitHubAppTokenManager {
      * Stores installations in an internal map for later lookup.
      */
     discoverInstallations(apiHost: string): Promise<void>;
-    /**
-     * Gets the installation ID for a given owner on the specified API host.
-     * Returns undefined if no installation is found.
-     */
     getInstallationId(apiHost: string, owner: string): number | undefined;
     /**
      * Gets an installation access token for the given owner.

package/dist/vcs/github-app-token-manager.js

@@ -1,7 +1,7 @@
 import { createSign } from "node:crypto";
 import { withRetry } from "../shared/retry-utils.js";
 /** Duration to cache tokens (45 minutes in milliseconds) */
-export const TOKEN_CACHE_DURATION_MS = 45 * 60 * 1000;
+const TOKEN_CACHE_DURATION_MS = 45 * 60 * 1000;
 /**
  * Manages GitHub App authentication tokens for multiple organizations.
  * Handles JWT generation, installation discovery, and token caching.
@@ -60,10 +60,8 @@ export class GitHubAppTokenManager {
                 },
             });
             if (!res.ok) {
-                const status = res.status;
-                // Throw error with status code for retry logic
-                const error = new Error(`GitHub API error: ${status}`);
-                throw error;
+                const body = await res.text().catch(() => "");
+                throw new Error(`GitHub API error: ${res.status}${body ? ` - ${body}` : ""}`);
             }
             return res;
         });
@@ -74,10 +72,6 @@ export class GitHubAppTokenManager {
         }
         this.discoveredHosts.add(apiHost);
     }
-    /**
-     * Gets the installation ID for a given owner on the specified API host.
-     * Returns undefined if no installation is found.
-     */
     getInstallationId(apiHost, owner) {
         const key = `${apiHost}:${owner}`;
         return this.installations.get(key);
@@ -111,9 +105,8 @@ export class GitHubAppTokenManager {
                 },
             });
             if (!res.ok) {
-                const status = res.status;
-                const error = new Error(`GitHub API error: ${status}`);
-                throw error;
+                const body = await res.text().catch(() => "");
+                throw new Error(`GitHub API error: ${res.status}${body ? ` - ${body}` : ""}`);
             }
             return res;
         });

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

@@ -1,14 +1,14 @@
-import { GitHubRepoInfo } from "../shared/repo-detector.js";
-import { PRResult } from "./pr-creator.js";
-import { BasePRStrategy, PRStrategyOptions, CloseExistingPROptions, MergeOptions, MergeResult } from "./pr-strategy.js";
+import type { PRResult } from "./types.js";
+import { BasePRStrategy } from "./pr-strategy.js";
+import type { PRStrategyOptions, CloseExistingPROptions, MergeOptions, MergeResult } from "./types.js";
 export declare class GitHubPRStrategy extends BasePRStrategy {
-    checkExistingPR(options: PRStrategyOptions): Promise<string | null>;
+    checkExistingPR(options: CloseExistingPROptions): Promise<string | null>;
     closeExistingPR(options: CloseExistingPROptions): Promise<boolean>;
     create(options: PRStrategyOptions): Promise<PRResult>;
     /**
      * Check if auto-merge is enabled on the repository.
      */
-    checkAutoMergeEnabled(repoInfo: GitHubRepoInfo, workDir: string, retries?: number, token?: string): Promise<boolean>;
+    private checkAutoMergeEnabled;
     /**
      * Build merge strategy flag for gh pr merge command.
      */

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

@@ -1,11 +1,13 @@
 import { existsSync, writeFileSync, unlinkSync } from "node:fs";
 import { join } from "node:path";
-import { escapeShellArg } from "../shared/shell-utils.js";
-import { isGitHubRepo } from "../shared/repo-detector.js";
-import { BasePRStrategy, } from "./pr-strategy.js";
-import { logger } from "../shared/logger.js";
-import { withRetry, isPermanentError } from "../shared/retry-utils.js";
+import { escapeShellArg, escapeRegExp } from "../shared/shell-utils.js";
+import { assertGitHubRepo } from "../shared/repo-detector.js";
+import { BasePRStrategy } from "./pr-strategy.js";
+import { withRetry } from "../shared/retry-utils.js";
 import { sanitizeCredentials } from "../shared/sanitize-utils.js";
+import { toErrorMessage, safeCleanup } from "../shared/type-guards.js";
+import { getStderr } from "../shared/command-executor.js";
+import { buildTokenEnv, getHostnameFlag } from "../shared/gh-api-utils.js";
 /**
  * Get the repo flag value for gh CLI commands.
  * Returns HOST/OWNER/REPO for GHE, OWNER/REPO for github.com.
@@ -16,22 +18,6 @@ function getRepoFlag(repoInfo) {
     }
     return `${repoInfo.owner}/${repoInfo.repo}`;
 }
-/**
- * Get the hostname flag for gh api commands.
- * Returns "--hostname HOST" for GHE, empty string for github.com.
- */
-function getHostnameFlag(repoInfo) {
-    if (repoInfo.host && repoInfo.host !== "github.com") {
-        return `--hostname ${escapeShellArg(repoInfo.host)}`;
-    }
-    return "";
-}
-/**
- * Escape special regex characters in a string.
- */
-function escapeRegExp(str) {
-    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
 /**
  * Build regex to match PR URLs for the given host.
  */
@@ -39,19 +25,10 @@ function buildPRUrlRegex(host) {
     const escapedHost = escapeRegExp(host);
     return new RegExp(`https://${escapedHost}/[\\w-]+/[\\w.-]+/pull/\\d+`);
 }
-/**
- * Build environment variables for gh CLI commands.
- * Uses env vars instead of command string interpolation to avoid shell injection.
- */
-function buildTokenEnv(token) {
-    return token ? { GH_TOKEN: token } : undefined;
-}
 export class GitHubPRStrategy extends BasePRStrategy {
     async checkExistingPR(options) {
         const { repoInfo, branchName, workDir, retries = 3, token } = options;
-        if (!isGitHubRepo(repoInfo)) {
-            throw new Error("Expected GitHub repository");
-        }
+        assertGitHubRepo(repoInfo, "GitHub PR strategy");
         const repoFlag = getRepoFlag(repoInfo);
         const tokenEnv = buildTokenEnv(token);
         const command = `gh pr list --repo ${escapeShellArg(repoFlag)} --head ${escapeShellArg(branchName)} --json url --jq '.[0].url'`;
@@ -60,25 +37,16 @@ export class GitHubPRStrategy extends BasePRStrategy {
             return existingPR || null;
         }
         catch (error) {
-            if (error instanceof Error) {
-                // Throw on permanent errors (auth failures, etc.)
-                if (isPermanentError(error)) {
-                    throw error;
-                }
-                // Log unexpected errors for debugging (expected: empty result means no PR)
-                const stderr = error.stderr ?? "";
-                if (stderr && !stderr.includes("no pull requests match")) {
-                    logger.info(`Debug: GitHub PR check failed - ${sanitizeCredentials(stderr).trim()}`);
-                }
+            const stderr = getStderr(error);
+            if (stderr && !stderr.includes("no pull requests match")) {
+                this.log?.debug(`GitHub PR check failed - ${sanitizeCredentials(stderr).trim()}`);
             }
             return null;
         }
     }
     async closeExistingPR(options) {
         const { repoInfo, branchName, baseBranch, workDir, retries = 3, token, } = options;
-        if (!isGitHubRepo(repoInfo)) {
-            throw new Error("Expected GitHub repository");
-        }
+        assertGitHubRepo(repoInfo, "GitHub PR strategy");
         // First check if there's an existing PR (pass token through)
         const existingUrl = await this.checkExistingPR({
             repoInfo,
@@ -86,8 +54,6 @@ export class GitHubPRStrategy extends BasePRStrategy {
             baseBranch,
             workDir,
             retries,
-            title: "", // Not used for check
-            body: "", // Not used for check
             token,
         });
         if (!existingUrl) {
@@ -96,10 +62,9 @@ export class GitHubPRStrategy extends BasePRStrategy {
         // Extract PR number from URL
         const prNumber = existingUrl.match(/\/pull\/(\d+)/)?.[1];
         if (!prNumber) {
-            throw new Error(`Could not extract PR number from URL: ${existingUrl}`);
+            this.log?.warn(`Could not extract PR number from URL: ${existingUrl}`);
+            return false;
         }
-        // Close the PR and delete the branch
-        // Token is passed via env var to avoid shell injection
         const repoFlag = getRepoFlag(repoInfo);
         const tokenEnv = buildTokenEnv(token);
         const command = `gh pr close ${escapeShellArg(prNumber)} --repo ${escapeShellArg(repoFlag)} --delete-branch`;
@@ -108,20 +73,16 @@ export class GitHubPRStrategy extends BasePRStrategy {
             return true;
         }
         catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            logger.info(`Warning: Failed to close existing PR #${prNumber}: ${message}`);
+            const message = toErrorMessage(error);
+            this.log?.warn(`Failed to close existing PR #${prNumber}: ${message}`);
             return false;
         }
     }
     async create(options) {
         const { repoInfo, title, body, branchName, baseBranch, workDir, retries = 3, token, labels, } = options;
-        if (!isGitHubRepo(repoInfo)) {
-            throw new Error("Expected GitHub repository");
-        }
-        // Write body to temp file to avoid shell escaping issues
+        assertGitHubRepo(repoInfo, "GitHub PR strategy");
         const bodyFile = join(workDir, this.bodyFilePath);
         writeFileSync(bodyFile, body, "utf-8");
-        // Token is passed via env var to avoid shell injection
         const tokenEnv = buildTokenEnv(token);
         let command = `gh pr create --title ${escapeShellArg(title)} --body-file ${escapeShellArg(bodyFile)} --base ${escapeShellArg(baseBranch)} --head ${escapeShellArg(branchName)}`;
         // Append label flags
@@ -133,7 +94,7 @@ export class GitHubPRStrategy extends BasePRStrategy {
         try {
             const result = await withRetry(() => this.executor.exec(command, workDir, { env: tokenEnv }), { retries });
             // Extract URL from output - use strict regex for valid PR URLs only
-            const host = repoInfo.host || "github.com";
+            const host = repoInfo.host;
             const urlRegex = buildPRUrlRegex(host);
             const urlMatch = result.match(urlRegex);
             if (!urlMatch) {
@@ -146,15 +107,10 @@ export class GitHubPRStrategy extends BasePRStrategy {
             };
         }
         finally {
-            // Clean up temp file - log warning on failure instead of throwing
-            try {
-                if (existsSync(bodyFile)) {
+            safeCleanup(() => {
+                if (existsSync(bodyFile))
                     unlinkSync(bodyFile);
-                }
-            }
-            catch (cleanupError) {
-                logger.info(`Warning: Failed to clean up temp file ${bodyFile}: ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}`);
-            }
+            }, `failed to remove ${bodyFile}`, this.log ?? { debug() { } });
         }
     }
     /**
@@ -163,7 +119,6 @@ export class GitHubPRStrategy extends BasePRStrategy {
     async checkAutoMergeEnabled(repoInfo, workDir, retries = 3, token) {
         const hostnameFlag = getHostnameFlag(repoInfo);
         const hostnamePart = hostnameFlag ? `${hostnameFlag} ` : "";
-        // Token is passed via env var to avoid shell injection
         const tokenEnv = buildTokenEnv(token);
         const command = `gh api ${hostnamePart}repos/${escapeShellArg(repoInfo.owner)}/${escapeShellArg(repoInfo.repo)} --jq '.allow_auto_merge // false'`;
         try {
@@ -172,7 +127,7 @@ export class GitHubPRStrategy extends BasePRStrategy {
         }
         catch (error) {
             // If we can't check, assume auto-merge is not enabled
-            logger.info(`Warning: Could not check auto-merge status: ${error instanceof Error ? error.message : String(error)}`);
+            this.log?.warn(`Could not check auto-merge status: ${toErrorMessage(error)}`);
             return false;
         }
     }
@@ -191,7 +146,7 @@ export class GitHubPRStrategy extends BasePRStrategy {
         }
     }
     async merge(options) {
-        const { prUrl, config, workDir, retries = 3, token } = options;
+        const { prUrl, repoInfo, config, workDir, retries = 3, token } = options;
         // Manual mode: do nothing
         if (config.mode === "manual") {
             return {
@@ -202,71 +157,38 @@ export class GitHubPRStrategy extends BasePRStrategy {
         }
         const strategyFlag = this.getMergeStrategyFlag(config.strategy);
         const deleteBranchFlag = config.deleteBranch ? "--delete-branch" : "";
-        // Token is passed via env var to avoid shell injection
         const tokenEnv = buildTokenEnv(token);
         if (config.mode === "auto") {
             // Check if auto-merge is enabled on the repo
-            // Extract host/owner/repo from PR URL (supports both github.com and GHE)
-            const match = prUrl.match(/https:\/\/([^/]+)\/([^/]+)\/([^/]+)/);
-            if (match) {
-                const repoInfo = {
-                    type: "github",
-                    gitUrl: prUrl,
-                    owner: match[2],
-                    repo: match[3],
-                    host: match[1],
-                };
-                const autoMergeEnabled = await this.checkAutoMergeEnabled(repoInfo, workDir, retries, token);
-                if (!autoMergeEnabled) {
-                    logger.info(`Warning: Auto-merge not enabled for '${repoInfo.owner}/${repoInfo.repo}'. PR left open for manual review.`);
-                    logger.info(`To enable: gh repo edit ${getRepoFlag(repoInfo)} --enable-auto-merge (requires admin)`);
-                    return {
-                        success: true,
-                        message: `Auto-merge not enabled for repository. PR left open for manual review.`,
-                        merged: false,
-                        autoMergeEnabled: false,
-                    };
-                }
-            }
-            // Enable auto-merge
-            const command = `gh pr merge ${escapeShellArg(prUrl)} --auto ${strategyFlag} ${deleteBranchFlag}`.trim();
-            try {
-                await withRetry(() => this.executor.exec(command, workDir, { env: tokenEnv }), { retries });
+            assertGitHubRepo(repoInfo, "GitHub PR strategy");
+            const autoMergeEnabled = await this.checkAutoMergeEnabled(repoInfo, workDir, retries, token);
+            if (!autoMergeEnabled) {
+                this.log?.warn(`Auto-merge not enabled for '${repoInfo.owner}/${repoInfo.repo}'. PR left open for manual review.`);
+                this.log?.info(`To enable: gh repo edit ${getRepoFlag(repoInfo)} --enable-auto-merge (requires admin)`);
                 return {
                     success: true,
-                    message: "Auto-merge enabled. PR will merge when checks pass.",
-                    merged: false,
-                    autoMergeEnabled: true,
-                };
-            }
-            catch (error) {
-                const message = error instanceof Error ? error.message : String(error);
-                return {
-                    success: false,
-                    message: `Failed to enable auto-merge: ${message}`,
+                    message: `Auto-merge not enabled for repository. PR left open for manual review.`,
                     merged: false,
+                    autoMergeEnabled: false,
                 };
             }
+            // Enable auto-merge
+            const autoCommand = `gh pr merge ${escapeShellArg(prUrl)} --auto ${strategyFlag} ${deleteBranchFlag}`.trim();
+            return this.executeMergeCommand(() => this.executor.exec(autoCommand, workDir, { env: tokenEnv }), retries, {
+                success: true,
+                message: "Auto-merge enabled. PR will merge when checks pass.",
+                merged: false,
+                autoMergeEnabled: true,
+            }, "Failed to enable auto-merge");
         }
         if (config.mode === "force") {
             // Force merge using admin privileges
-            const command = `gh pr merge ${escapeShellArg(prUrl)} --admin ${strategyFlag} ${deleteBranchFlag}`.trim();
-            try {
-                await withRetry(() => this.executor.exec(command, workDir, { env: tokenEnv }), { retries });
-                return {
-                    success: true,
-                    message: "PR merged successfully using admin privileges.",
-                    merged: true,
-                };
-            }
-            catch (error) {
-                const message = error instanceof Error ? error.message : String(error);
-                return {
-                    success: false,
-                    message: `Failed to force merge: ${message}`,
-                    merged: false,
-                };
-            }
+            const forceCommand = `gh pr merge ${escapeShellArg(prUrl)} --admin ${strategyFlag} ${deleteBranchFlag}`.trim();
+            return this.executeMergeCommand(() => this.executor.exec(forceCommand, workDir, { env: tokenEnv }), retries, {
+                success: true,
+                message: "PR merged successfully using admin privileges.",
+                merged: true,
+            }, "Failed to force merge");
         }
         return {
             success: false,

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

@@ -1,8 +1,10 @@
-import { PRResult } from "./pr-creator.js";
-import { BasePRStrategy, PRStrategyOptions, CloseExistingPROptions, MergeOptions, MergeResult } from "./pr-strategy.js";
+import type { PRResult } from "./types.js";
+import { BasePRStrategy } from "./pr-strategy.js";
+import type { IPRStrategyLogger } from "./pr-strategy.js";
+import type { PRStrategyOptions, CloseExistingPROptions, MergeOptions, MergeResult } from "./types.js";
 import { ICommandExecutor } from "../shared/command-executor.js";
 export declare class GitLabPRStrategy extends BasePRStrategy {
-    constructor(executor?: ICommandExecutor);
+    constructor(executor?: ICommandExecutor, log?: IPRStrategyLogger);
     /**
      * Build the repo flag for glab commands.
      * Format: namespace/repo (supports nested groups)
@@ -20,7 +22,7 @@ export declare class GitLabPRStrategy extends BasePRStrategy {
      * Build merge strategy flags for glab mr merge command.
      */
     private getMergeStrategyFlag;
-    checkExistingPR(options: PRStrategyOptions): Promise<string | null>;
+    checkExistingPR(options: CloseExistingPROptions): Promise<string | null>;
     closeExistingPR(options: CloseExistingPROptions): Promise<boolean>;
     create(options: PRStrategyOptions): Promise<PRResult>;
     merge(options: MergeOptions): Promise<MergeResult>;