@aspruyt/xfg 1.1.0 → 1.3.0

package/README.md

@@ -5,7 +5,7 @@
 [![npm downloads](https://img.shields.io/npm/dw/@aspruyt/xfg.svg)](https://www.npmjs.com/package/@aspruyt/xfg)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
 
-A CLI tool that syncs JSON, JSON5, YAML, or text configuration files across multiple GitHub and Azure DevOps repositories by creating pull requests. Output format is automatically detected from the target filename extension (`.json` → JSON, `.json5` → JSON5, `.yaml`/`.yml` → YAML, other → text).
+A CLI tool that syncs JSON, JSON5, YAML, or text configuration files across multiple GitHub, Azure DevOps, and GitLab repositories by creating pull requests (or merge requests for GitLab). Output format is automatically detected from the target filename extension (`.json` → JSON, `.json5` → JSON5, `.yaml`/`.yml` → YAML, other → text).
 
 ## Table of Contents
 
@@ -72,7 +72,7 @@ xfg --config ./config.yaml
 - **Override Mode** - Skip merging entirely for specific repos
 - **Empty Files** - Create files with no content (e.g., `.prettierignore`)
 - **YAML Comments** - Add header comments and schema directives to YAML files
-- **GitHub & Azure DevOps** - Works with both platforms
+- **Multi-Platform** - Works with GitHub, Azure DevOps, and GitLab (including self-hosted)
 - **Auto-Merge PRs** - Automatically merge PRs when checks pass, or force merge with admin privileges
 - **Dry-Run Mode** - Preview changes without creating PRs
 - **Error Resilience** - Continues processing if individual repos fail
@@ -118,6 +118,20 @@ az login
 az devops configure --defaults organization=https://dev.azure.com/YOUR_ORG project=YOUR_PROJECT
 ```
 
+### GitLab Authentication
+
+Before using with GitLab repositories, authenticate with the GitLab CLI:
+
+```bash
+glab auth login
+```
+
+For self-hosted GitLab instances:
+
+```bash
+glab auth login --hostname gitlab.example.com
+```
+
 ## Usage
 
 ```bash
@@ -679,11 +693,11 @@ repos:
 
 **Merge Modes:**
 
-| Mode     | GitHub Behavior                                      | Azure DevOps Behavior                  |
-| -------- | ---------------------------------------------------- | -------------------------------------- |
-| `manual` | Leave PR open for review                             | Leave PR open for review               |
-| `auto`   | Enable auto-merge (requires repo setup, **default**) | Enable auto-complete (**default**)     |
-| `force`  | Merge with `--admin` (bypass checks)                 | Bypass policies with `--bypass-policy` |
+| Mode     | GitHub Behavior                                      | Azure DevOps Behavior                  | GitLab Behavior                            |
+| -------- | ---------------------------------------------------- | -------------------------------------- | ------------------------------------------ |
+| `manual` | Leave PR open for review                             | Leave PR open for review               | Leave MR open for review                   |
+| `auto`   | Enable auto-merge (requires repo setup, **default**) | Enable auto-complete (**default**)     | Merge when pipeline succeeds (**default**) |
+| `force`  | Merge with `--admin` (bypass checks)                 | Bypass policies with `--bypass-policy` | Merge immediately                          |
 
 **GitHub Auto-Merge Note:** The `auto` mode requires auto-merge to be enabled in the repository settings. If not enabled, the tool will warn and leave the PR open for manual review. Enable it with:
 
@@ -713,6 +727,14 @@ xfg --config ./config.yaml --merge force
 - SSH: `git@ssh.dev.azure.com:v3/organization/project/repo`
 - HTTPS: `https://dev.azure.com/organization/project/_git/repo`
 
+### GitLab
+
+- SSH: `git@gitlab.com:owner/repo.git`
+- HTTPS: `https://gitlab.com/owner/repo.git`
+- Nested groups: `git@gitlab.com:org/group/subgroup/repo.git`
+- Self-hosted SSH: `git@gitlab.example.com:owner/repo.git`
+- Self-hosted HTTPS: `https://gitlab.example.com/owner/repo.git`
+
 ## How It Works
 
 ```mermaid
@@ -737,11 +759,13 @@ flowchart TB
     end
 
     subgraph Platform["PR Creation"]
-        COMMIT --> PR_DETECT{GitHub or<br/>Azure DevOps?}
+        COMMIT --> PR_DETECT{Platform?}
         PR_DETECT -->|GitHub| GH_PR[Create PR via gh CLI]
         PR_DETECT -->|Azure DevOps| AZ_PR[Create PR via az CLI]
-        GH_PR --> PR_CREATED[PR Created]
+        PR_DETECT -->|GitLab| GL_PR[Create MR via glab CLI]
+        GH_PR --> PR_CREATED[PR/MR Created]
         AZ_PR --> PR_CREATED
+        GL_PR --> PR_CREATED
     end
 
     subgraph AutoMerge["Auto-Merge (default)"]
@@ -890,11 +914,25 @@ az login
 az devops configure --defaults organization=https://dev.azure.com/YOUR_ORG
 ```
 
+**GitLab:**
+
+```bash
+# Check authentication status
+glab auth status
+
+# Re-authenticate if needed
+glab auth login
+
+# For self-hosted instances
+glab auth login --hostname gitlab.example.com
+```
+
 ### Permission Denied
 
 - Ensure your token has write access to the target repositories
 - For GitHub, the token needs `repo` scope
 - For Azure DevOps, ensure the user/service account has "Contribute to pull requests" permission
+- For GitLab, ensure the user has at least "Developer" role on the project
 
 ### Branch Already Exists
 

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/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;
@@ -68,7 +68,7 @@ export class AzurePRStrategy extends BasePRStrategy {
             return false;
         }
         // Abandon the PR (Azure DevOps equivalent of closing)
-        const abandonCommand = `az repos pr update --id ${escapeShellArg(prInfo.prId)} --status abandoned --org ${escapeShellArg(orgUrl)} --project ${escapeShellArg(prInfo.project)}`;
+        const abandonCommand = `az repos pr update --id ${escapeShellArg(prInfo.prId)} --status abandoned --org ${escapeShellArg(orgUrl)}`;
         try {
             await withRetry(() => this.executor.exec(abandonCommand, workDir), {
                 retries,
@@ -79,12 +79,15 @@ export class AzurePRStrategy extends BasePRStrategy {
             logger.info(`Warning: Failed to abandon PR #${prInfo.prId}: ${message}`);
             return false;
         }
-        // Delete the source branch
-        const deleteBranchCommand = `az repos ref delete --name refs/heads/${escapeShellArg(branchName)} --repository ${escapeShellArg(azureRepoInfo.repo)} --org ${escapeShellArg(orgUrl)} --project ${escapeShellArg(azureRepoInfo.project)}`;
+        // Delete the source branch - need to get object_id first
         try {
-            await withRetry(() => this.executor.exec(deleteBranchCommand, workDir), {
-                retries,
-            });
+            // Get the branch's object_id
+            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 });
+            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 });
+            }
         }
         catch (error) {
             // Branch deletion failure is not critical - PR is already abandoned
@@ -168,7 +171,7 @@ export class AzurePRStrategy extends BasePRStrategy {
             : "";
         if (config.mode === "auto") {
             // Enable auto-complete (no pre-check needed - always available in Azure DevOps)
-            const command = `az repos pr update --id ${escapeShellArg(prInfo.prId)} --auto-complete true ${squashFlag} ${deleteBranchFlag} --org ${escapeShellArg(orgUrl)} --project ${escapeShellArg(prInfo.project)}`.trim();
+            const command = `az repos pr update --id ${escapeShellArg(prInfo.prId)} --auto-complete true ${squashFlag} ${deleteBranchFlag} --org ${escapeShellArg(orgUrl)}`.trim();
             try {
                 await withRetry(() => this.executor.exec(command, workDir), {
                     retries,
@@ -192,7 +195,7 @@ export class AzurePRStrategy extends BasePRStrategy {
         if (config.mode === "force") {
             // Bypass policies and complete the PR
             const bypassReason = config.bypassReason ?? "Automated config sync via xfg";
-            const command = `az repos pr update --id ${escapeShellArg(prInfo.prId)} --bypass-policy true --bypass-policy-reason ${escapeShellArg(bypassReason)} --status completed ${squashFlag} ${deleteBranchFlag} --org ${escapeShellArg(orgUrl)} --project ${escapeShellArg(prInfo.project)}`.trim();
+            const command = `az repos pr update --id ${escapeShellArg(prInfo.prId)} --bypass-policy true --bypass-policy-reason ${escapeShellArg(bypassReason)} --status completed ${squashFlag} ${deleteBranchFlag} --org ${escapeShellArg(orgUrl)}`.trim();
             try {
                 await withRetry(() => this.executor.exec(command, workDir), {
                     retries,

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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@aspruyt/xfg",
-  "version": "1.1.0",
-  "description": "CLI tool to sync JSON or YAML configuration files across multiple GitHub and Azure DevOps repositories",
+  "version": "1.3.0",
+  "description": "CLI tool to sync JSON or YAML configuration files across multiple GitHub, Azure DevOps, and GitLab repositories",
   "type": "module",
   "main": "dist/index.js",
   "bin": {
@@ -26,8 +26,9 @@
     "build": "tsc",
     "start": "node dist/index.js",
     "dev": "ts-node src/index.ts",
-    "test": "node --import tsx --test src/config.test.ts src/merge.test.ts src/env.test.ts src/repo-detector.test.ts src/pr-creator.test.ts src/git-ops.test.ts src/logger.test.ts src/workspace-utils.test.ts src/strategies/pr-strategy.test.ts src/strategies/github-pr-strategy.test.ts src/strategies/azure-pr-strategy.test.ts src/repository-processor.test.ts src/retry-utils.test.ts src/command-executor.test.ts src/shell-utils.test.ts src/index.test.ts src/config-formatter.test.ts src/config-validator.test.ts src/config-normalizer.test.ts src/diff-utils.test.ts",
-    "test:integration": "npm run build && node --import tsx --test src/integration.test.ts",
+    "test": "node --import tsx --test src/config.test.ts src/merge.test.ts src/env.test.ts src/repo-detector.test.ts src/pr-creator.test.ts src/git-ops.test.ts src/logger.test.ts src/workspace-utils.test.ts src/strategies/pr-strategy.test.ts src/strategies/github-pr-strategy.test.ts src/strategies/azure-pr-strategy.test.ts src/strategies/gitlab-pr-strategy.test.ts src/repository-processor.test.ts src/retry-utils.test.ts src/command-executor.test.ts src/shell-utils.test.ts src/index.test.ts src/config-formatter.test.ts src/config-validator.test.ts src/config-normalizer.test.ts src/diff-utils.test.ts",
+    "test:integration:github": "npm run build && node --import tsx --test src/integration-github.test.ts",
+    "test:integration:ado": "npm run build && node --import tsx --test src/integration-ado.test.ts",
     "prepublishOnly": "npm run build"
   },
   "keywords": [
@@ -39,7 +40,9 @@
     "cli",
     "github",
     "azure-devops",
-    "pull-request"
+    "gitlab",
+    "pull-request",
+    "merge-request"
   ],
   "author": "Anthony Spruyt",
   "license": "MIT",