@aspruyt/xfg 1.0.3 → 1.2.0

package/dist/logger.js

@@ -1,4 +1,5 @@
 import chalk from "chalk";
+import { formatStatusBadge } from "./diff-utils.js";
 export class Logger {
     stats = {
         total: 0,
@@ -31,6 +32,35 @@ export class Logger {
         console.log(chalk.red(`[${current}/${this.stats.total}] ✗`) +
             ` ${repoName}: ${error}`);
     }
+    /**
+     * Display a file diff with status badge.
+     * Used in dry-run mode to show what would change.
+     */
+    fileDiff(fileName, status, diffLines) {
+        const badge = formatStatusBadge(status);
+        console.log(`    ${badge} ${fileName}`);
+        // Only show diff lines for NEW or MODIFIED files
+        if (status !== "UNCHANGED" && diffLines.length > 0) {
+            for (const line of diffLines) {
+                console.log(`      ${line}`);
+            }
+        }
+    }
+    /**
+     * Display summary statistics for dry-run diff.
+     */
+    diffSummary(newCount, modifiedCount, unchangedCount) {
+        const parts = [];
+        if (newCount > 0)
+            parts.push(chalk.green(`${newCount} new`));
+        if (modifiedCount > 0)
+            parts.push(chalk.yellow(`${modifiedCount} modified`));
+        if (unchangedCount > 0)
+            parts.push(chalk.gray(`${unchangedCount} unchanged`));
+        if (parts.length > 0) {
+            console.log(chalk.gray(`    Summary: ${parts.join(", ")}`));
+        }
+    }
     summary() {
         console.log("");
         console.log(chalk.bold("Summary:"));

package/dist/repo-detector.d.ts

@@ -1,4 +1,4 @@
-export type RepoType = "github" | "azure-devops";
+export type RepoType = "github" | "azure-devops" | "gitlab";
 interface BaseRepoInfo {
     gitUrl: string;
     repo: string;
@@ -13,9 +13,16 @@ export interface AzureDevOpsRepoInfo extends BaseRepoInfo {
     organization: string;
     project: string;
 }
-export type RepoInfo = GitHubRepoInfo | AzureDevOpsRepoInfo;
+export interface GitLabRepoInfo extends BaseRepoInfo {
+    type: "gitlab";
+    owner: string;
+    namespace: string;
+    host: string;
+}
+export type RepoInfo = GitHubRepoInfo | AzureDevOpsRepoInfo | GitLabRepoInfo;
 export declare function isGitHubRepo(info: RepoInfo): info is GitHubRepoInfo;
 export declare function isAzureDevOpsRepo(info: RepoInfo): info is AzureDevOpsRepoInfo;
+export declare function isGitLabRepo(info: RepoInfo): info is GitLabRepoInfo;
 export declare function detectRepoType(gitUrl: string): RepoType;
 export declare function parseGitUrl(gitUrl: string): RepoInfo;
 export declare function getRepoDisplayName(repoInfo: RepoInfo): string;

package/dist/repo-detector.js

@@ -5,6 +5,9 @@ export function isGitHubRepo(info) {
 export function isAzureDevOpsRepo(info) {
     return info.type === "azure-devops";
 }
+export function isGitLabRepo(info) {
+    return info.type === "gitlab";
+}
 /**
  * Valid URL patterns for supported repository types.
  */
@@ -13,8 +16,33 @@ const AZURE_DEVOPS_URL_PATTERNS = [
     /^git@ssh\.dev\.azure\.com:/,
     /^https?:\/\/dev\.azure\.com\//,
 ];
+const GITLAB_SAAS_URL_PATTERNS = [
+    /^git@gitlab\.com:/,
+    /^https?:\/\/gitlab\.com\//,
+];
+/**
+ * Check if a URL looks like a GitLab-style URL (used for self-hosted detection).
+ * This is a fallback for URLs that don't match known platforms.
+ */
+function isGitLabStyleUrl(gitUrl) {
+    // SSH: git@hostname:path/to/repo.git
+    const sshMatch = gitUrl.match(/^git@([^:]+):(.+?)(?:\.git)?$/);
+    if (sshMatch) {
+        const path = sshMatch[2];
+        // Must have at least one slash (owner/repo or namespace/repo)
+        return path.includes("/");
+    }
+    // HTTPS: https://hostname/path/to/repo.git
+    const httpsMatch = gitUrl.match(/^https?:\/\/([^/]+)\/(.+?)(?:\.git)?$/);
+    if (httpsMatch) {
+        const path = httpsMatch[2];
+        // Must have at least one slash (owner/repo or namespace/repo)
+        return path.includes("/");
+    }
+    return false;
+}
 export function detectRepoType(gitUrl) {
-    // Check for Azure DevOps formats
+    // Check for Azure DevOps formats first (most specific patterns)
     for (const pattern of AZURE_DEVOPS_URL_PATTERNS) {
         if (pattern.test(gitUrl)) {
             return "azure-devops";
@@ -26,14 +54,27 @@ export function detectRepoType(gitUrl) {
             return "github";
         }
     }
+    // Check for GitLab SaaS formats
+    for (const pattern of GITLAB_SAAS_URL_PATTERNS) {
+        if (pattern.test(gitUrl)) {
+            return "gitlab";
+        }
+    }
+    // For unrecognized URLs, try GitLab-style parsing as fallback (self-hosted)
+    if (isGitLabStyleUrl(gitUrl)) {
+        return "gitlab";
+    }
     // Throw for unrecognized URL formats
-    throw new Error(`Unrecognized git URL format: ${gitUrl}. Supported formats: GitHub (git@github.com: or https://github.com/) and Azure DevOps (git@ssh.dev.azure.com: or https://dev.azure.com/)`);
+    throw new Error(`Unrecognized git URL format: ${gitUrl}. Supported formats: GitHub (git@github.com: or https://github.com/), Azure DevOps (git@ssh.dev.azure.com: or https://dev.azure.com/), and GitLab (git@gitlab.com: or https://gitlab.com/)`);
 }
 export function parseGitUrl(gitUrl) {
     const type = detectRepoType(gitUrl);
     if (type === "azure-devops") {
         return parseAzureDevOpsUrl(gitUrl);
     }
+    if (type === "gitlab") {
+        return parseGitLabUrl(gitUrl);
+    }
     return parseGitHubUrl(gitUrl);
 }
 function parseGitHubUrl(gitUrl) {
@@ -90,9 +131,50 @@ function parseAzureDevOpsUrl(gitUrl) {
     }
     throw new Error(`Unable to parse Azure DevOps URL: ${gitUrl}`);
 }
+function parseGitLabUrl(gitUrl) {
+    // Handle SSH format: git@gitlab.com:owner/repo.git or git@gitlab.com:org/group/repo.git
+    // Also handles self-hosted: git@gitlab.example.com:owner/repo.git
+    const sshMatch = gitUrl.match(/^git@([^:]+):(.+?)(?:\.git)?$/);
+    if (sshMatch) {
+        const host = sshMatch[1];
+        const fullPath = sshMatch[2];
+        return parseGitLabPath(gitUrl, host, fullPath);
+    }
+    // Handle HTTPS format: https://gitlab.com/owner/repo.git or https://gitlab.com/org/group/repo.git
+    // Also handles self-hosted: https://gitlab.example.com/owner/repo.git
+    const httpsMatch = gitUrl.match(/^https?:\/\/([^/]+)\/(.+?)(?:\.git)?$/);
+    if (httpsMatch) {
+        const host = httpsMatch[1];
+        const fullPath = httpsMatch[2];
+        return parseGitLabPath(gitUrl, host, fullPath);
+    }
+    throw new Error(`Unable to parse GitLab URL: ${gitUrl}`);
+}
+function parseGitLabPath(gitUrl, host, fullPath) {
+    // Split path into segments: org/group/subgroup/repo -> [org, group, subgroup, repo]
+    const segments = fullPath.split("/");
+    if (segments.length < 2) {
+        throw new Error(`Unable to parse GitLab URL: ${gitUrl}`);
+    }
+    // Last segment is repo, everything else is namespace
+    const repo = segments[segments.length - 1];
+    const namespace = segments.slice(0, -1).join("/");
+    const owner = segments[0]; // First segment for display
+    return {
+        type: "gitlab",
+        gitUrl,
+        repo,
+        owner,
+        namespace,
+        host,
+    };
+}
 export function getRepoDisplayName(repoInfo) {
     if (repoInfo.type === "azure-devops") {
         return `${repoInfo.organization}/${repoInfo.project}/${repoInfo.repo}`;
     }
+    if (repoInfo.type === "gitlab") {
+        return `${repoInfo.namespace}/${repoInfo.repo}`;
+    }
     return `${repoInfo.owner}/${repoInfo.repo}`;
 }

package/dist/repository-processor.js

@@ -7,6 +7,7 @@ import { createPR, mergePR } from "./pr-creator.js";
 import { logger } from "./logger.js";
 import { getPRStrategy } from "./strategies/index.js";
 import { defaultExecutor } from "./command-executor.js";
+import { getFileStatus, generateDiff, createDiffStats, incrementDiffStats, } from "./diff-utils.js";
 /**
  * Determines if a file should be marked as executable.
  * .sh files are auto-executable unless explicit executable: false is set.
@@ -69,7 +70,19 @@ export class RepositoryProcessor {
             this.log.info(`Creating branch: ${branchName}`);
             await this.gitOps.createBranch(branchName);
             // Step 5: Write all config files and track changes
+            //
+            // DESIGN NOTE: Change detection differs between dry-run and normal mode:
+            // - Dry-run: Uses wouldChange() for read-only content comparison (no side effects)
+            // - Normal: Uses git status after writing (source of truth for what git will commit)
+            //
+            // This is intentional. git status is more accurate because it respects .gitattributes
+            // (line ending normalization, filters) and detects executable bit changes. However,
+            // it requires actually writing files, which defeats dry-run's purpose.
+            //
+            // For config files (JSON/YAML), these approaches produce identical results in practice.
+            // Edge cases (repos with unusual git attributes on config files) are essentially nonexistent.
             const changedFiles = [];
+            const diffStats = createDiffStats();
             for (const file of repoConfig.files) {
                 const filePath = join(workDir, file.fileName);
                 const fileExistsLocal = existsSync(filePath);
@@ -93,10 +106,18 @@ export class RepositoryProcessor {
                     ? "update"
                     : "create";
                 if (dryRun) {
-                    // In dry-run, check if file would change without writing
-                    if (this.gitOps.wouldChange(file.fileName, fileContent)) {
+                    // In dry-run, check if file would change and show diff
+                    const existingContent = this.gitOps.getFileContent(file.fileName);
+                    const changed = this.gitOps.wouldChange(file.fileName, fileContent);
+                    const status = getFileStatus(existingContent !== null, changed);
+                    // Track stats
+                    incrementDiffStats(diffStats, status);
+                    if (changed) {
                         changedFiles.push({ fileName: file.fileName, action });
                     }
+                    // Generate and display diff
+                    const diffLines = generateDiff(existingContent, fileContent, file.fileName);
+                    this.log.fileDiff(file.fileName, status, diffLines);
                 }
                 else {
                     // Write the file
@@ -115,6 +136,10 @@ export class RepositoryProcessor {
                     await this.gitOps.setExecutable(file.fileName);
                 }
             }
+            // Show diff summary in dry-run mode
+            if (dryRun) {
+                this.log.diffSummary(diffStats.newCount, diffStats.modifiedCount, diffStats.unchangedCount);
+            }
             // Step 6: Check for changes (exclude skipped files)
             let hasChanges;
             if (dryRun) {
@@ -124,15 +149,21 @@ export class RepositoryProcessor {
                 hasChanges = await this.gitOps.hasChanges();
                 // If there are changes, determine which files changed
                 if (hasChanges) {
-                    // Rebuild the changed files list by checking git status
-                    // Skip files that were already marked as skipped (createOnly)
+                    // Get the actual list of changed files from git status
+                    const gitChangedFiles = new Set(await this.gitOps.getChangedFiles());
+                    // Preserve skipped files (createOnly)
                     const skippedFiles = new Set(changedFiles
                         .filter((f) => f.action === "skip")
                         .map((f) => f.fileName));
+                    // Only add files that actually changed according to git
                     for (const file of repoConfig.files) {
                         if (skippedFiles.has(file.fileName)) {
                             continue; // Already tracked as skipped
                         }
+                        // Only include files that git reports as changed
+                        if (!gitChangedFiles.has(file.fileName)) {
+                            continue; // File didn't actually change
+                        }
                         const filePath = join(workDir, file.fileName);
                         const action = existsSync(filePath)
                             ? "update"

package/dist/shell-utils.js

@@ -6,6 +6,10 @@
  * @returns The escaped string wrapped in single quotes
  */
 export function escapeShellArg(arg) {
+    // Defense-in-depth: reject null bytes even if upstream validation should catch them
+    if (arg.includes("\0")) {
+        throw new Error("Shell argument contains null byte");
+    }
     // Use single quotes and escape any single quotes within
     // 'string' -> quote ends, escaped quote, quote starts again
     return `'${arg.replace(/'/g, "'\\''")}'`;

package/dist/strategies/azure-pr-strategy.js

@@ -14,7 +14,7 @@ export class AzurePRStrategy extends BasePRStrategy {
         return `https://dev.azure.com/${encodeURIComponent(repoInfo.organization)}`;
     }
     buildPRUrl(repoInfo, prId) {
-        return `https://dev.azure.com/${encodeURIComponent(repoInfo.organization)}/${encodeURIComponent(repoInfo.project)}/_git/${encodeURIComponent(repoInfo.repo)}/pullrequest/${prId}`;
+        return `https://dev.azure.com/${encodeURIComponent(repoInfo.organization)}/${encodeURIComponent(repoInfo.project)}/_git/${encodeURIComponent(repoInfo.repo)}/pullrequest/${prId.trim()}`;
     }
     async checkExistingPR(options) {
         const { repoInfo, branchName, baseBranch, workDir, retries = 3 } = options;

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

@@ -52,8 +52,7 @@ export class GitHubPRStrategy extends BasePRStrategy {
         // Extract PR number from URL
         const prNumber = existingUrl.match(/\/pull\/(\d+)/)?.[1];
         if (!prNumber) {
-            logger.info(`Warning: Could not extract PR number from URL: ${existingUrl}`);
-            return false;
+            throw new Error(`Could not extract PR number from URL: ${existingUrl}`);
         }
         // Close the PR and delete the branch
         const command = `gh pr close ${escapeShellArg(prNumber)} --repo ${escapeShellArg(repoInfo.owner)}/${escapeShellArg(repoInfo.repo)} --delete-branch`;
@@ -78,10 +77,13 @@ export class GitHubPRStrategy extends BasePRStrategy {
         const command = `gh pr create --title ${escapeShellArg(title)} --body-file ${escapeShellArg(bodyFile)} --base ${escapeShellArg(baseBranch)} --head ${escapeShellArg(branchName)}`;
         try {
             const result = await withRetry(() => this.executor.exec(command, workDir), { retries });
-            // Extract URL from output
-            const urlMatch = result.match(/https:\/\/github\.com\/[^\s]+/);
+            // Extract URL from output - use strict regex for valid PR URLs only
+            const urlMatch = result.match(/https:\/\/github\.com\/[\w-]+\/[\w.-]+\/pull\/\d+/);
+            if (!urlMatch) {
+                throw new Error(`Could not parse PR URL from output: ${result}`);
+            }
             return {
-                url: urlMatch?.[0] ?? result,
+                url: urlMatch[0],
                 success: true,
                 message: "PR created successfully",
             };

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

@@ -0,0 +1,27 @@
+import { PRResult } from "../pr-creator.js";
+import { BasePRStrategy, PRStrategyOptions, CloseExistingPROptions, MergeOptions, MergeResult } from "./pr-strategy.js";
+import { CommandExecutor } from "../command-executor.js";
+export declare class GitLabPRStrategy extends BasePRStrategy {
+    constructor(executor?: CommandExecutor);
+    /**
+     * Build the repo flag for glab commands.
+     * Format: namespace/repo (supports nested groups)
+     */
+    private getRepoFlag;
+    /**
+     * Build the MR URL from repo info and MR IID.
+     */
+    private buildMRUrl;
+    /**
+     * Parse MR URL to extract components.
+     */
+    private parseMRUrl;
+    /**
+     * Build merge strategy flags for glab mr merge command.
+     */
+    private getMergeStrategyFlag;
+    checkExistingPR(options: PRStrategyOptions): Promise<string | null>;
+    closeExistingPR(options: CloseExistingPROptions): Promise<boolean>;
+    create(options: PRStrategyOptions): Promise<PRResult>;
+    merge(options: MergeOptions): Promise<MergeResult>;
+}

package/dist/strategies/gitlab-pr-strategy.js

@@ -0,0 +1,276 @@
+import { existsSync, writeFileSync, unlinkSync } from "node:fs";
+import { join } from "node:path";
+import { escapeShellArg } from "../shell-utils.js";
+import { isGitLabRepo } from "../repo-detector.js";
+import { BasePRStrategy, } from "./pr-strategy.js";
+import { logger } from "../logger.js";
+import { withRetry, isPermanentError } from "../retry-utils.js";
+export class GitLabPRStrategy extends BasePRStrategy {
+    constructor(executor) {
+        super(executor);
+        this.bodyFilePath = ".mr-description.md";
+    }
+    /**
+     * Build the repo flag for glab commands.
+     * Format: namespace/repo (supports nested groups)
+     */
+    getRepoFlag(repoInfo) {
+        return `${repoInfo.namespace}/${repoInfo.repo}`;
+    }
+    /**
+     * Build the MR URL from repo info and MR IID.
+     */
+    buildMRUrl(repoInfo, mrIid) {
+        return `https://${repoInfo.host}/${repoInfo.namespace}/${repoInfo.repo}/-/merge_requests/${mrIid}`;
+    }
+    /**
+     * Parse MR URL to extract components.
+     */
+    parseMRUrl(mrUrl) {
+        // URL format: https://gitlab.com/namespace/repo/-/merge_requests/123
+        // Nested: https://gitlab.com/org/group/subgroup/repo/-/merge_requests/123
+        // Use specific path segment pattern to avoid ReDoS (polynomial regex)
+        // Pattern: protocol://host/path-segments/-/merge_requests/id
+        const match = mrUrl.match(/https?:\/\/([^/]+)\/((?:[^/]+\/)*[^/]+)\/-\/merge_requests\/(\d+)/);
+        if (!match)
+            return null;
+        const host = match[1];
+        const fullPath = match[2];
+        const mrIid = match[3];
+        // Split path to get namespace and repo
+        const segments = fullPath.split("/");
+        if (segments.length < 2)
+            return null;
+        const repo = segments[segments.length - 1];
+        const namespace = segments.slice(0, -1).join("/");
+        return { host, namespace, repo, mrIid };
+    }
+    /**
+     * Build merge strategy flags for glab mr merge command.
+     */
+    getMergeStrategyFlag(strategy) {
+        switch (strategy) {
+            case "squash":
+                return "--squash";
+            case "rebase":
+                return "--rebase";
+            case "merge":
+            default:
+                return "";
+        }
+    }
+    async checkExistingPR(options) {
+        const { repoInfo, branchName, workDir, retries = 3 } = options;
+        if (!isGitLabRepo(repoInfo)) {
+            throw new Error("Expected GitLab repository");
+        }
+        const repoFlag = this.getRepoFlag(repoInfo);
+        // Use glab mr list with JSON output for reliable parsing
+        const command = `glab mr list --source-branch ${escapeShellArg(branchName)} --state opened -R ${escapeShellArg(repoFlag)} -F json`;
+        try {
+            const result = await withRetry(() => this.executor.exec(command, workDir), { retries });
+            if (!result || result.trim() === "" || result.trim() === "[]") {
+                return null;
+            }
+            // Parse JSON to get MR IID
+            const mrs = JSON.parse(result);
+            if (Array.isArray(mrs) && mrs.length > 0 && mrs[0].iid) {
+                return this.buildMRUrl(repoInfo, String(mrs[0].iid));
+            }
+            return null;
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                // Throw on permanent errors (auth failures, etc.)
+                if (isPermanentError(error)) {
+                    throw error;
+                }
+                // Log unexpected errors for debugging
+                const stderr = error.stderr ?? "";
+                if (stderr && !stderr.includes("no merge requests")) {
+                    logger.info(`Debug: GitLab MR check failed - ${stderr.trim()}`);
+                }
+            }
+            return null;
+        }
+    }
+    async closeExistingPR(options) {
+        const { repoInfo, branchName, baseBranch, workDir, retries = 3 } = options;
+        if (!isGitLabRepo(repoInfo)) {
+            throw new Error("Expected GitLab repository");
+        }
+        // First check if there's an existing MR
+        const existingUrl = await this.checkExistingPR({
+            repoInfo,
+            branchName,
+            baseBranch,
+            workDir,
+            retries,
+            title: "", // Not used for check
+            body: "", // Not used for check
+        });
+        if (!existingUrl) {
+            return false;
+        }
+        // Extract MR IID from URL
+        const mrInfo = this.parseMRUrl(existingUrl);
+        if (!mrInfo) {
+            throw new Error(`Could not extract MR IID from URL: ${existingUrl}`);
+        }
+        const repoFlag = this.getRepoFlag(repoInfo);
+        // Close the MR
+        const closeCommand = `glab mr close ${escapeShellArg(mrInfo.mrIid)} -R ${escapeShellArg(repoFlag)}`;
+        try {
+            await withRetry(() => this.executor.exec(closeCommand, workDir), {
+                retries,
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            logger.info(`Warning: Failed to close existing MR !${mrInfo.mrIid}: ${message}`);
+            return false;
+        }
+        // Delete the source branch via git
+        const deleteBranchCommand = `git push origin --delete ${escapeShellArg(branchName)}`;
+        try {
+            await withRetry(() => this.executor.exec(deleteBranchCommand, workDir), {
+                retries,
+            });
+        }
+        catch (error) {
+            // Branch deletion failure is not critical
+            const message = error instanceof Error ? error.message : String(error);
+            logger.info(`Warning: Failed to delete branch ${branchName}: ${message}`);
+        }
+        return true;
+    }
+    async create(options) {
+        const { repoInfo, title, body, branchName, baseBranch, workDir, retries = 3, } = options;
+        if (!isGitLabRepo(repoInfo)) {
+            throw new Error("Expected GitLab repository");
+        }
+        const repoFlag = this.getRepoFlag(repoInfo);
+        // Write description to temp file to avoid shell escaping issues
+        const descFile = join(workDir, this.bodyFilePath);
+        writeFileSync(descFile, body, "utf-8");
+        // glab mr create with description from file
+        const command = `glab mr create --source-branch ${escapeShellArg(branchName)} --target-branch ${escapeShellArg(baseBranch)} --title ${escapeShellArg(title)} --description "$(cat ${escapeShellArg(descFile)})" --yes -R ${escapeShellArg(repoFlag)}`;
+        try {
+            const result = await withRetry(() => this.executor.exec(command, workDir), { retries });
+            // Extract MR URL from output
+            // glab typically outputs the URL directly
+            const urlMatch = result.match(/https:\/\/[^\s]+\/-\/merge_requests\/\d+/);
+            if (urlMatch) {
+                return {
+                    url: urlMatch[0],
+                    success: true,
+                    message: "MR created successfully",
+                };
+            }
+            // Fallback: extract MR number and build URL
+            const mrMatch = result.match(/!(\d+)/);
+            if (mrMatch) {
+                return {
+                    url: this.buildMRUrl(repoInfo, mrMatch[1]),
+                    success: true,
+                    message: "MR created successfully",
+                };
+            }
+            throw new Error(`Could not parse MR URL from output: ${result}`);
+        }
+        finally {
+            // Clean up temp file - log warning on failure instead of throwing
+            try {
+                if (existsSync(descFile)) {
+                    unlinkSync(descFile);
+                }
+            }
+            catch (cleanupError) {
+                logger.info(`Warning: Failed to clean up temp file ${descFile}: ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}`);
+            }
+        }
+    }
+    async merge(options) {
+        const { prUrl, config, workDir, retries = 3 } = options;
+        // Manual mode: do nothing
+        if (config.mode === "manual") {
+            return {
+                success: true,
+                message: "MR left open for manual review",
+                merged: false,
+            };
+        }
+        // Parse MR URL to extract details
+        const mrInfo = this.parseMRUrl(prUrl);
+        if (!mrInfo) {
+            return {
+                success: false,
+                message: `Invalid GitLab MR URL: ${prUrl}`,
+                merged: false,
+            };
+        }
+        const repoFlag = `${mrInfo.namespace}/${mrInfo.repo}`;
+        const strategyFlag = this.getMergeStrategyFlag(config.strategy);
+        const deleteBranchFlag = config.deleteBranch
+            ? "--remove-source-branch"
+            : "";
+        if (config.mode === "auto") {
+            // Enable auto-merge when pipeline succeeds
+            // glab mr merge <id> --when-pipeline-succeeds [--squash] [--remove-source-branch]
+            const flagParts = [
+                "--when-pipeline-succeeds",
+                strategyFlag,
+                deleteBranchFlag,
+            ].filter(Boolean);
+            const command = `glab mr merge ${escapeShellArg(mrInfo.mrIid)} ${flagParts.join(" ")} -R ${escapeShellArg(repoFlag)} -y`;
+            try {
+                await withRetry(() => this.executor.exec(command.trim(), workDir), {
+                    retries,
+                });
+                return {
+                    success: true,
+                    message: "Auto-merge enabled. MR will merge when pipeline succeeds.",
+                    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}`,
+                    merged: false,
+                };
+            }
+        }
+        if (config.mode === "force") {
+            // Force merge immediately
+            // glab mr merge <id> --yes [--squash] [--remove-source-branch]
+            const flagParts = [strategyFlag, deleteBranchFlag].filter(Boolean);
+            const command = `glab mr merge ${escapeShellArg(mrInfo.mrIid)} ${flagParts.join(" ")} -R ${escapeShellArg(repoFlag)} -y`;
+            try {
+                await withRetry(() => this.executor.exec(command.trim(), workDir), {
+                    retries,
+                });
+                return {
+                    success: true,
+                    message: "MR merged successfully.",
+                    merged: true,
+                };
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                return {
+                    success: false,
+                    message: `Failed to force merge: ${message}`,
+                    merged: false,
+                };
+            }
+        }
+        return {
+            success: false,
+            message: `Unknown merge mode: ${config.mode}`,
+            merged: false,
+        };
+    }
+}

package/dist/strategies/index.d.ts

@@ -5,6 +5,7 @@ export type { PRStrategy, PRStrategyOptions, CloseExistingPROptions, PRMergeConf
 export { BasePRStrategy, PRWorkflowExecutor } from "./pr-strategy.js";
 export { GitHubPRStrategy } from "./github-pr-strategy.js";
 export { AzurePRStrategy } from "./azure-pr-strategy.js";
+export { GitLabPRStrategy } from "./gitlab-pr-strategy.js";
 /**
  * Factory function to get the appropriate PR strategy for a repository.
  * @param repoInfo - Repository information

package/dist/strategies/index.js

@@ -1,9 +1,11 @@
-import { isGitHubRepo, isAzureDevOpsRepo } from "../repo-detector.js";
+import { isGitHubRepo, isAzureDevOpsRepo, isGitLabRepo, } from "../repo-detector.js";
 import { GitHubPRStrategy } from "./github-pr-strategy.js";
 import { AzurePRStrategy } from "./azure-pr-strategy.js";
+import { GitLabPRStrategy } from "./gitlab-pr-strategy.js";
 export { BasePRStrategy, PRWorkflowExecutor } from "./pr-strategy.js";
 export { GitHubPRStrategy } from "./github-pr-strategy.js";
 export { AzurePRStrategy } from "./azure-pr-strategy.js";
+export { GitLabPRStrategy } from "./gitlab-pr-strategy.js";
 /**
  * Factory function to get the appropriate PR strategy for a repository.
  * @param repoInfo - Repository information
@@ -16,6 +18,9 @@ export function getPRStrategy(repoInfo, executor) {
     if (isAzureDevOpsRepo(repoInfo)) {
         return new AzurePRStrategy(executor);
     }
+    if (isGitLabRepo(repoInfo)) {
+        return new GitLabPRStrategy(executor);
+    }
     // Type exhaustiveness check - should never reach here
     const _exhaustive = repoInfo;
     throw new Error(`Unknown repository type: ${JSON.stringify(_exhaustive)}`);