@aspruyt/xfg 1.5.1 → 1.6.0

package/README.md

@@ -55,7 +55,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
-- **Multi-Platform** - Works with GitHub, Azure DevOps, and GitLab (including self-hosted)
+- **Multi-Platform** - Works with GitHub (including GitHub Enterprise Server), 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

package/dist/config-normalizer.js

@@ -136,5 +136,6 @@ export function normalizeConfig(raw) {
     return {
         repos: expandedRepos,
         prTemplate: raw.prTemplate,
+        githubHosts: raw.githubHosts,
     };
 }

package/dist/config-validator.js

@@ -83,6 +83,24 @@ export function validateRawConfig(config) {
     if (!config.repos || !Array.isArray(config.repos)) {
         throw new Error("Config missing required field: repos (must be an array)");
     }
+    // Validate githubHosts if provided
+    if (config.githubHosts !== undefined) {
+        if (!Array.isArray(config.githubHosts) ||
+            !config.githubHosts.every((h) => typeof h === "string")) {
+            throw new Error("githubHosts must be an array of strings");
+        }
+        for (const host of config.githubHosts) {
+            if (!host) {
+                throw new Error("githubHosts entries must be non-empty hostnames");
+            }
+            if (host.includes("://")) {
+                throw new Error(`githubHosts entries must be hostnames only, not URLs. Got: ${host}`);
+            }
+            if (host.includes("/")) {
+                throw new Error(`githubHosts entries must be hostnames only, not paths. Got: ${host}`);
+            }
+        }
+    }
     // Validate each repo
     for (let i = 0; i < config.repos.length; i++) {
         const repo = config.repos[i];

package/dist/config.d.ts

@@ -35,6 +35,7 @@ export interface RawConfig {
     repos: RawRepoConfig[];
     prOptions?: PRMergeOptions;
     prTemplate?: string;
+    githubHosts?: string[];
 }
 export interface FileContent {
     fileName: string;
@@ -52,5 +53,6 @@ export interface RepoConfig {
 export interface Config {
     repos: RepoConfig[];
     prTemplate?: string;
+    githubHosts?: string[];
 }
 export declare function loadConfig(filePath: string): Config;

package/dist/index.js

@@ -115,7 +115,9 @@ async function main() {
         const current = i + 1;
         let repoInfo;
         try {
-            repoInfo = parseGitUrl(repoConfig.git);
+            repoInfo = parseGitUrl(repoConfig.git, {
+                githubHosts: config.githubHosts,
+            });
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);

package/dist/repo-detector.d.ts

@@ -1,4 +1,7 @@
 export type RepoType = "github" | "azure-devops" | "gitlab";
+export interface RepoDetectorContext {
+    githubHosts?: string[];
+}
 interface BaseRepoInfo {
     gitUrl: string;
     repo: string;
@@ -6,6 +9,7 @@ interface BaseRepoInfo {
 export interface GitHubRepoInfo extends BaseRepoInfo {
     type: "github";
     owner: string;
+    host: string;
 }
 export interface AzureDevOpsRepoInfo extends BaseRepoInfo {
     type: "azure-devops";
@@ -23,7 +27,7 @@ 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 detectRepoType(gitUrl: string, context?: RepoDetectorContext): RepoType;
+export declare function parseGitUrl(gitUrl: string, context?: RepoDetectorContext): RepoInfo;
 export declare function getRepoDisplayName(repoInfo: RepoInfo): string;
 export {};

package/dist/repo-detector.js

@@ -8,6 +8,22 @@ export function isAzureDevOpsRepo(info) {
 export function isGitLabRepo(info) {
     return info.type === "gitlab";
 }
+/**
+ * Extract hostname from a git URL.
+ */
+function extractHostFromUrl(gitUrl) {
+    // SSH: git@hostname:path
+    const sshMatch = gitUrl.match(/^git@([^:]+):/);
+    if (sshMatch) {
+        return sshMatch[1];
+    }
+    // HTTPS: https://hostname/path
+    const httpsMatch = gitUrl.match(/^https?:\/\/([^/]+)/);
+    if (httpsMatch) {
+        return httpsMatch[1];
+    }
+    return null;
+}
 /**
  * Valid URL patterns for supported repository types.
  */
@@ -41,8 +57,16 @@ function isGitLabStyleUrl(gitUrl) {
     }
     return false;
 }
-export function detectRepoType(gitUrl) {
-    // Check for Azure DevOps formats first (most specific patterns)
+export function detectRepoType(gitUrl, context) {
+    // Check for GitHub Enterprise hosts first (if configured)
+    if (context?.githubHosts?.length) {
+        const host = extractHostFromUrl(gitUrl)?.toLowerCase();
+        const normalizedHosts = context.githubHosts.map((h) => h.toLowerCase());
+        if (host && normalizedHosts.includes(host)) {
+            return "github";
+        }
+    }
+    // Check for Azure DevOps formats (most specific patterns)
     for (const pattern of AZURE_DEVOPS_URL_PATTERNS) {
         if (pattern.test(gitUrl)) {
             return "azure-devops";
@@ -67,37 +91,41 @@ export function detectRepoType(gitUrl) {
     // Throw for unrecognized URL formats
     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);
+export function parseGitUrl(gitUrl, context) {
+    const type = detectRepoType(gitUrl, context);
     if (type === "azure-devops") {
         return parseAzureDevOpsUrl(gitUrl);
     }
     if (type === "gitlab") {
         return parseGitLabUrl(gitUrl);
     }
-    return parseGitHubUrl(gitUrl);
+    // For GitHub, extract the host from the URL
+    const host = extractHostFromUrl(gitUrl) ?? "github.com";
+    return parseGitHubUrl(gitUrl, host);
 }
-function parseGitHubUrl(gitUrl) {
-    // Handle SSH format: git@github.com:owner/repo.git
+function parseGitHubUrl(gitUrl, host) {
+    // Handle SSH format: git@hostname:owner/repo.git
     // Use (.+?) with end anchor to handle repo names with dots (e.g., my.repo.git)
-    const sshMatch = gitUrl.match(/git@github\.com:([^/]+)\/(.+?)(?:\.git)?$/);
+    const sshMatch = gitUrl.match(/^git@[^:]+:([^/]+)\/(.+?)(?:\.git)?$/);
     if (sshMatch) {
         return {
             type: "github",
             gitUrl,
             owner: sshMatch[1],
             repo: sshMatch[2],
+            host,
         };
     }
-    // Handle HTTPS format: https://github.com/owner/repo.git
+    // Handle HTTPS format: https://hostname/owner/repo.git
     // Use (.+?) with end anchor to handle repo names with dots
-    const httpsMatch = gitUrl.match(/https?:\/\/github\.com\/([^/]+)\/(.+?)(?:\.git)?$/);
+    const httpsMatch = gitUrl.match(/^https?:\/\/[^/]+\/([^/]+)\/(.+?)(?:\.git)?$/);
     if (httpsMatch) {
         return {
             type: "github",
             gitUrl,
             owner: httpsMatch[1],
             repo: httpsMatch[2],
+            host,
         };
     }
     throw new Error(`Unable to parse GitHub URL: ${gitUrl}`);

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

@@ -5,13 +5,47 @@ import { isGitHubRepo } from "../repo-detector.js";
 import { BasePRStrategy, } from "./pr-strategy.js";
 import { logger } from "../logger.js";
 import { withRetry, isPermanentError } from "../retry-utils.js";
+/**
+ * Get the repo flag value for gh CLI commands.
+ * Returns HOST/OWNER/REPO for GHE, OWNER/REPO for github.com.
+ */
+function getRepoFlag(repoInfo) {
+    if (repoInfo.host && repoInfo.host !== "github.com") {
+        return `${repoInfo.host}/${repoInfo.owner}/${repoInfo.repo}`;
+    }
+    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.
+ */
+function buildPRUrlRegex(host) {
+    const escapedHost = escapeRegExp(host);
+    return new RegExp(`https://${escapedHost}/[\\w-]+/[\\w.-]+/pull/\\d+`);
+}
 export class GitHubPRStrategy extends BasePRStrategy {
     async checkExistingPR(options) {
         const { repoInfo, branchName, workDir, retries = 3 } = options;
         if (!isGitHubRepo(repoInfo)) {
             throw new Error("Expected GitHub repository");
         }
-        const command = `gh pr list --head ${escapeShellArg(branchName)} --json url --jq '.[0].url'`;
+        const repoFlag = getRepoFlag(repoInfo);
+        const command = `gh pr list --repo ${escapeShellArg(repoFlag)} --head ${escapeShellArg(branchName)} --json url --jq '.[0].url'`;
         try {
             const existingPR = await withRetry(() => this.executor.exec(command, workDir), { retries });
             return existingPR || null;
@@ -55,7 +89,8 @@ export class GitHubPRStrategy extends BasePRStrategy {
             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`;
+        const repoFlag = getRepoFlag(repoInfo);
+        const command = `gh pr close ${escapeShellArg(prNumber)} --repo ${escapeShellArg(repoFlag)} --delete-branch`;
         try {
             await withRetry(() => this.executor.exec(command, workDir), { retries });
             return true;
@@ -78,7 +113,9 @@ export class GitHubPRStrategy extends BasePRStrategy {
         try {
             const result = await withRetry(() => this.executor.exec(command, workDir), { retries });
             // Extract URL from output - use strict regex for valid PR URLs only
-            const urlMatch = result.match(/https:\/\/github\.com\/[\w-]+\/[\w.-]+\/pull\/\d+/);
+            const host = repoInfo.host || "github.com";
+            const urlRegex = buildPRUrlRegex(host);
+            const urlMatch = result.match(urlRegex);
             if (!urlMatch) {
                 throw new Error(`Could not parse PR URL from output: ${result}`);
             }
@@ -104,7 +141,9 @@ export class GitHubPRStrategy extends BasePRStrategy {
      * Check if auto-merge is enabled on the repository.
      */
     async checkAutoMergeEnabled(repoInfo, workDir, retries = 3) {
-        const command = `gh api repos/${escapeShellArg(repoInfo.owner)}/${escapeShellArg(repoInfo.repo)} --jq '.allow_auto_merge // false'`;
+        const hostnameFlag = getHostnameFlag(repoInfo);
+        const hostnamePart = hostnameFlag ? `${hostnameFlag} ` : "";
+        const command = `gh api ${hostnamePart}repos/${escapeShellArg(repoInfo.owner)}/${escapeShellArg(repoInfo.repo)} --jq '.allow_auto_merge // false'`;
         try {
             const result = await withRetry(() => this.executor.exec(command, workDir), { retries });
             return result.trim() === "true";
@@ -143,19 +182,20 @@ export class GitHubPRStrategy extends BasePRStrategy {
         const deleteBranchFlag = config.deleteBranch ? "--delete-branch" : "";
         if (config.mode === "auto") {
             // Check if auto-merge is enabled on the repo
-            // Extract owner/repo from PR URL
-            const match = prUrl.match(/github\.com\/([^/]+)\/([^/]+)/);
+            // 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[1],
-                    repo: match[2],
+                    owner: match[2],
+                    repo: match[3],
+                    host: match[1],
                 };
                 const autoMergeEnabled = await this.checkAutoMergeEnabled(repoInfo, workDir, retries);
                 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 ${repoInfo.owner}/${repoInfo.repo} --enable-auto-merge (requires admin)`);
+                    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.`,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aspruyt/xfg",
-  "version": "1.5.1",
+  "version": "1.6.0",
   "description": "CLI tool to sync JSON, JSON5, YAML, or text configuration files across multiple Git repositories by creating pull requests",
   "type": "module",
   "main": "dist/index.js",