@aspruyt/xfg 3.13.1 → 4.0.1

package/README.md

@@ -47,11 +47,8 @@ npm install -g @aspruyt/xfg
 # Authenticate (GitHub)
 gh auth login
 
-# Sync files across repos
+# Sync files, settings, rulesets, and labels across repos
 xfg sync --config ./config.yaml
-
-# Apply repository settings and rulesets
-xfg settings --config ./config.yaml
 ```
 
 ### Example Config

package/dist/cli/index.d.ts

@@ -1,6 +1,3 @@
 export { runSync } from "./sync-command.js";
-export { runSettings } from "./settings-command.js";
-export { program } from "./program.js";
-export { type IRepositoryProcessor, type ProcessorFactory, type IRulesetProcessor, type RulesetProcessorFactory, type RepoSettingsProcessorFactory, type IRepoSettingsProcessor, type ILabelsProcessor, type LabelsProcessorFactory, defaultProcessorFactory, defaultRulesetProcessorFactory, defaultRepoSettingsProcessorFactory, defaultLabelsProcessorFactory, } from "./types.js";
+export { type IRepositoryProcessor, type ProcessorFactory, type IRulesetProcessor, type RulesetProcessorFactory, type RepoSettingsProcessorFactory, type ILabelsProcessor, type LabelsProcessorFactory, defaultProcessorFactory, defaultRulesetProcessorFactory, defaultRepoSettingsProcessorFactory, defaultLabelsProcessorFactory, } from "./types.js";
 export type { SyncOptions, SharedOptions } from "./sync-command.js";
-export type { SettingsOptions } from "./settings-command.js";

package/dist/cli/index.js

@@ -1,7 +1,5 @@
 // CLI command implementations
 export { runSync } from "./sync-command.js";
-export { runSettings } from "./settings-command.js";
-export { program } from "./program.js";
 // Export types - using 'export type' for type aliases, but interfaces need special handling
 // For ESM compatibility, re-export everything from types.js
 export { 

package/dist/cli/program.js

@@ -3,11 +3,15 @@ import { dirname, join } from "node:path";
 import { readFileSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { runSync } from "./sync-command.js";
-import { runSettings } from "./settings-command.js";
-// Get version from package.json
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
-const packageJson = JSON.parse(readFileSync(join(__dirname, "../..", "package.json"), "utf-8"));
+let packageJson;
+try {
+    packageJson = JSON.parse(readFileSync(join(__dirname, "../..", "package.json"), "utf-8"));
+}
+catch {
+    packageJson = { version: "0.0.0" };
+}
 // =============================================================================
 // Shared CLI Options
 // =============================================================================
@@ -56,15 +60,4 @@ const syncCommand = new Command("sync")
 });
 addSharedOptions(syncCommand);
 program.addCommand(syncCommand);
-// Settings command (repository settings and rulesets)
-const settingsCommand = new Command("settings")
-    .description("Manage GitHub repository settings and rulesets")
-    .action((opts) => {
-    runSettings(opts).catch((error) => {
-        console.error("Fatal error:", error);
-        process.exit(1);
-    });
-});
-addSharedOptions(settingsCommand);
-program.addCommand(settingsCommand);
 export { program };

package/dist/cli/{settings/results-collector.d.ts → results-collector.d.ts}

@@ -1,4 +1,4 @@
-import type { ProcessorResults } from "../settings-report-builder.js";
+import type { ProcessorResults } from "./settings-report-builder.js";
 /**
  * Collects processing results for the SettingsReport.
  * Provides a centralized way to track results across rulesets, repo settings, and labels.

package/dist/cli/{settings/results-collector.js → results-collector.js}

@@ -1,3 +1,4 @@
+import { toErrorMessage } from "../shared/type-guards.js";
 /**
  * Collects processing results for the SettingsReport.
  * Provides a centralized way to track results across rulesets, repo settings, and labels.
@@ -14,7 +15,7 @@ export class ResultsCollector {
     }
     appendError(repoName, error) {
         const existing = this.getOrCreate(repoName);
-        const errorMsg = error instanceof Error ? error.message : String(error);
+        const errorMsg = toErrorMessage(error);
         if (existing.error) {
             existing.error += `; ${errorMsg}`;
         }

package/dist/cli/settings-report-builder.d.ts

@@ -1,7 +1,5 @@
 import type { SettingsReport } from "../output/settings-report.js";
-import type { RepoSettingsPlanEntry } from "../settings/repo-settings/formatter.js";
-import type { RulesetPlanEntry } from "../settings/rulesets/formatter.js";
-import type { LabelsPlanEntry } from "../settings/labels/formatter.js";
+import type { RepoSettingsPlanEntry, RulesetPlanEntry, LabelsPlanEntry } from "../settings/index.js";
 /**
  * Result from processing a repository's settings and rulesets.
  * Used to collect results during settings command execution.

package/dist/cli/sync-command.d.ts

@@ -1,26 +1,3 @@
-import { MergeMode, MergeStrategy } from "../config/index.js";
-import { ProcessorFactory } from "./types.js";
-import { type IRepoLifecycleManager } from "../lifecycle/index.js";
-/**
- * Shared options common to all commands.
- */
-export interface SharedOptions {
-    config: string;
-    dryRun?: boolean;
-    workDir?: string;
-    retries?: number;
-    noDelete?: boolean;
-}
-/**
- * Options specific to the sync command.
- */
-export interface SyncOptions extends SharedOptions {
-    branch?: string;
-    merge?: MergeMode;
-    mergeStrategy?: MergeStrategy;
-    deleteBranch?: boolean;
-}
-/**
- * Run the sync command - synchronizes files across repositories.
- */
-export declare function runSync(options: SyncOptions, processorFactory?: ProcessorFactory, lifecycleManager?: IRepoLifecycleManager): Promise<void>;
+import { type SyncDependencies, type SyncOptions } from "./types.js";
+export type { SharedOptions, SyncOptions } from "./types.js";
+export declare function runSync(options: SyncOptions, deps?: SyncDependencies): Promise<void>;

package/dist/cli/sync-command.js

@@ -1,17 +1,22 @@
 import { resolve, join } from "node:path";
 import { existsSync } from "node:fs";
-import { loadRawConfig, normalizeConfig, } from "../config/index.js";
+import { loadRawConfig, normalizeConfig } from "../config/index.js";
 import { validateForSync } from "../config/validator.js";
 import { parseGitUrl, getRepoDisplayName, isGitHubRepo, } from "../shared/repo-detector.js";
-import { sanitizeBranchName, validateBranchName } from "../vcs/git-ops.js";
-import { hasGitHubAppCredentials, GitHubAppTokenManager, } from "../vcs/index.js";
+import { sanitizeBranchName, validateBranchName } from "../vcs/branch-utils.js";
+import { createTokenManager } from "../vcs/index.js";
 import { logger } from "../shared/logger.js";
 import { generateWorkspaceName } from "../shared/workspace-utils.js";
-import { defaultProcessorFactory } from "./types.js";
+import { defaultProcessorFactory, defaultRulesetProcessorFactory, defaultRepoSettingsProcessorFactory, defaultLabelsProcessorFactory, } from "./types.js";
+import { ResultsCollector } from "./results-collector.js";
+import { buildSettingsReport } from "./settings-report-builder.js";
+import { formatSettingsReportCLI } from "../output/settings-report.js";
 import { buildSyncReport } from "./sync-report-builder.js";
 import { formatSyncReportCLI } from "../output/sync-report.js";
 import { buildLifecycleReport, formatLifecycleReportCLI, hasLifecycleChanges, } from "../output/lifecycle-report.js";
 import { writeUnifiedSummary } from "../output/unified-summary.js";
+import { toErrorMessage } from "../shared/type-guards.js";
+import { resolveGitHubToken } from "../shared/gh-api-utils.js";
 import { RepoLifecycleManager, runLifecycleCheck, toCreateRepoSettings, } from "../lifecycle/index.js";
 /**
  * Get unique file names from all repos in the config
@@ -46,9 +51,6 @@ function formatFileNames(fileNames) {
     }
     return `${fileNames.length} files`;
 }
-/**
- * Determine merge outcome from processor result
- */
 function determineMergeOutcome(result) {
     if (!result.success)
         return undefined;
@@ -60,200 +62,331 @@ function determineMergeOutcome(result) {
         return "auto";
     return "manual";
 }
-/**
- * Run the sync command - synchronizes files across repositories.
- */
-export async function runSync(options, processorFactory = defaultProcessorFactory, lifecycleManager) {
-    const configPath = resolve(options.config);
-    if (!existsSync(configPath)) {
-        console.error(`Config file not found: ${configPath}`);
-        process.exit(1);
-    }
-    console.log(`Loading config from: ${configPath}`);
-    if (options.dryRun) {
-        console.log("Running in DRY RUN mode - no changes will be made\n");
-    }
-    const rawConfig = loadRawConfig(configPath);
-    try {
-        validateForSync(rawConfig);
-    }
-    catch (error) {
-        console.error(error instanceof Error ? error.message : String(error));
-        process.exit(1);
-    }
-    const config = normalizeConfig(rawConfig);
-    const fileNames = getUniqueFileNames(config);
-    let branchName;
-    if (options.branch) {
-        validateBranchName(options.branch);
-        branchName = options.branch;
-    }
-    else {
-        branchName = generateBranchName(fileNames);
-    }
-    logger.setTotal(config.repos.length);
-    console.log(`Found ${config.repos.length} repositories to process`);
-    console.log(`Target files: ${formatFileNames(fileNames)}`);
-    console.log(`Branch: ${branchName}\n`);
-    const processor = processorFactory();
-    const lm = lifecycleManager ?? new RepoLifecycleManager(undefined, options.retries);
-    const tokenManager = hasGitHubAppCredentials()
-        ? new GitHubAppTokenManager(process.env.XFG_GITHUB_APP_ID, process.env.XFG_GITHUB_APP_PRIVATE_KEY)
-        : null;
-    const reportResults = [];
-    const lifecycleReportInputs = [];
-    for (let i = 0; i < config.repos.length; i++) {
-        const repoConfig = config.repos[i];
-        if (options.merge || options.mergeStrategy || options.deleteBranch) {
-            repoConfig.prOptions = {
-                ...repoConfig.prOptions,
-                merge: options.merge ?? repoConfig.prOptions?.merge,
-                mergeStrategy: options.mergeStrategy ?? repoConfig.prOptions?.mergeStrategy,
-                deleteBranch: options.deleteBranch ?? repoConfig.prOptions?.deleteBranch,
-            };
-        }
-        const current = i + 1;
-        let repoInfo;
-        try {
-            repoInfo = parseGitUrl(repoConfig.git, {
-                githubHosts: config.githubHosts,
-            });
+function logSettingsResult(result, label, current, repoName, settingsCollector) {
+    if (result.planOutput?.lines?.length) {
+        logger.info("");
+        logger.info(`${repoName} - ${label}:`);
+        for (const line of result.planOutput.lines) {
+            logger.info(line);
         }
-        catch (error) {
-            logger.error(current, repoConfig.git, String(error));
-            reportResults.push({
-                repoName: repoConfig.git,
-                success: false,
-                fileChanges: [],
-                error: error instanceof Error ? error.message : String(error),
-            });
-            continue;
-        }
-        const repoName = getRepoDisplayName(repoInfo);
-        const workDir = resolve(join(options.workDir ?? "./tmp", generateWorkspaceName(i)));
-        // Resolve auth token for lifecycle gh commands
-        let lifecycleToken;
-        if (isGitHubRepo(repoInfo)) {
-            try {
-                lifecycleToken =
-                    (await tokenManager?.getTokenForRepo(repoInfo)) ??
-                        process.env.GH_TOKEN;
-            }
-            catch {
-                lifecycleToken = process.env.GH_TOKEN;
+        if (result.warnings?.length) {
+            for (const warning of result.warnings) {
+                logger.warn(warning);
             }
         }
-        // Check if repo exists, create/fork/migrate if needed
-        try {
-            const { outputLines, lifecycleResult } = await runLifecycleCheck(repoConfig, repoInfo, i, {
-                dryRun: options.dryRun ?? false,
-                resolvedWorkDir: workDir,
-                githubHosts: config.githubHosts,
-                token: lifecycleToken,
-            }, lm, config.settings?.repo);
-            for (const line of outputLines) {
-                logger.info(line);
-            }
-            // Collect lifecycle result for report
-            const createSettings = toCreateRepoSettings(config.settings?.repo);
-            lifecycleReportInputs.push({
-                repoName,
-                action: lifecycleResult.action,
-                upstream: repoConfig.upstream,
-                source: repoConfig.source,
-                settings: createSettings
-                    ? {
-                        visibility: createSettings.visibility,
-                        description: createSettings.description,
-                    }
-                    : undefined,
-            });
-            // In dry-run, skip processing repos that don't exist yet
-            if (options.dryRun && lifecycleResult.action !== "existed") {
-                reportResults.push({
-                    repoName,
-                    success: true,
-                    fileChanges: [],
+    }
+    else if (!result.skipped && result.success) {
+        logger.success(current, repoName, `${label}: ${result.message}`);
+    }
+    if (!result.success && !result.skipped) {
+        logger.error(current, repoName, `${label}: ${result.message}`);
+        settingsCollector.appendError(repoName, result.message);
+    }
+}
+async function applyRepoSettings(ctx) {
+    const { repoConfig, repoInfo, repoName, current, options, token, settingsCollector, rulesetProcessorFactory, repoSettingsProcessorFactory, labelsProcessorFactory, } = ctx;
+    if (!repoConfig.settings || !isGitHubRepo(repoInfo))
+        return;
+    const settingsDescriptors = [
+        {
+            key: "rulesets",
+            label: "Rulesets",
+            run: async () => {
+                const result = await rulesetProcessorFactory().process(repoConfig, repoInfo, {
+                    dryRun: options.dryRun,
+                    noDelete: options.noDelete,
+                    token,
                 });
-                continue;
-            }
-        }
-        catch (error) {
-            logger.error(current, repoName, `Lifecycle error: ${error instanceof Error ? error.message : String(error)}`);
-            reportResults.push({
-                repoName,
-                success: false,
-                fileChanges: [],
-                error: error instanceof Error ? error.message : String(error),
-            });
+                if (!result.skipped) {
+                    settingsCollector.getOrCreate(repoName).rulesetResult = result;
+                }
+                return result;
+            },
+        },
+        {
+            key: "labels",
+            label: "Labels",
+            run: async () => {
+                const result = await labelsProcessorFactory().process(repoConfig, repoInfo, {
+                    dryRun: options.dryRun,
+                    noDelete: options.noDelete,
+                    token,
+                });
+                if (!result.skipped) {
+                    settingsCollector.getOrCreate(repoName).labelsResult = result;
+                }
+                return result;
+            },
+        },
+        {
+            key: "repo",
+            label: "Repo Settings",
+            run: async () => {
+                const result = await repoSettingsProcessorFactory().process(repoConfig, repoInfo, { dryRun: options.dryRun, token });
+                if (!result.skipped) {
+                    settingsCollector.getOrCreate(repoName).settingsResult = result;
+                }
+                return result;
+            },
+        },
+    ];
+    for (const desc of settingsDescriptors) {
+        const settingsValue = repoConfig.settings[desc.key];
+        if (!settingsValue || Object.keys(settingsValue).length === 0)
             continue;
-        }
         try {
-            logger.progress(current, repoName, "Processing...");
-            const result = await processor.process(repoConfig, repoInfo, {
-                branchName,
-                workDir,
-                configId: config.id,
-                dryRun: options.dryRun,
-                retries: options.retries,
-                prTemplate: config.prTemplate,
-                noDelete: options.noDelete,
-            });
-            const mergeOutcome = determineMergeOutcome(result);
-            reportResults.push({
-                repoName,
-                success: result.success,
-                fileChanges: (result.fileChanges ?? []).map((f) => ({
-                    path: f.path,
-                    action: f.action,
-                })),
-                prUrl: result.prUrl,
-                mergeOutcome,
-                error: result.success ? undefined : result.message,
-            });
-            if (result.skipped) {
-                logger.skip(current, repoName, result.message);
-            }
-            else if (result.success) {
-                logger.success(current, repoName, result.message);
-            }
-            else {
-                logger.error(current, repoName, result.message);
-            }
+            const result = await desc.run();
+            logSettingsResult(result, desc.label, current, repoName, settingsCollector);
         }
         catch (error) {
-            logger.error(current, repoName, String(error));
-            reportResults.push({
-                repoName,
-                success: false,
-                fileChanges: [],
-                error: error instanceof Error ? error.message : String(error),
-            });
+            logger.error(current, repoName, `${desc.label}: ${toErrorMessage(error)}`);
+            settingsCollector.appendError(repoName, error);
         }
     }
-    // Build and display lifecycle report (before sync report)
+}
+function displayReports(reportResults, lifecycleReportInputs, settingsCollector, dryRun) {
     const lifecycleReport = buildLifecycleReport(lifecycleReportInputs);
     if (hasLifecycleChanges(lifecycleReport)) {
-        console.log("");
+        logger.log("");
         for (const line of formatLifecycleReportCLI(lifecycleReport)) {
-            console.log(line);
+            logger.log(line);
         }
     }
-    // Build and display sync report
     const report = buildSyncReport(reportResults);
-    console.log("");
+    logger.log("");
     for (const line of formatSyncReportCLI(report)) {
-        console.log(line);
+        logger.log(line);
+    }
+    // Build and display settings report (if any settings were processed)
+    const settingsResults = settingsCollector.getAll();
+    let settingsReport;
+    if (settingsResults.length > 0) {
+        settingsReport = buildSettingsReport(settingsResults);
+        const settingsLines = formatSettingsReportCLI(settingsReport);
+        if (settingsLines.length > 0) {
+            logger.log("");
+            for (const line of settingsLines) {
+                logger.log(line);
+            }
+        }
     }
     // Write unified summary to GITHUB_STEP_SUMMARY
     writeUnifiedSummary({
         lifecycle: lifecycleReport,
         sync: report,
-        dryRun: options.dryRun ?? false,
+        settings: settingsReport,
+        dryRun,
     });
-    // Exit with error if any failures
-    const hasErrors = reportResults.some((r) => r.error);
-    if (hasErrors) {
-        process.exit(1);
+}
+/**
+ * Process a single repository: resolve URL, run lifecycle check, sync files, apply settings.
+ * Pushes results into ctx.reportResults, ctx.lifecycleReportInputs, and ctx.settingsCollector.
+ */
+async function processSingleRepo(repoConfig, index, ctx) {
+    const { config, options } = ctx;
+    const current = index + 1;
+    // Apply CLI-level PR option overrides
+    if (options.merge || options.mergeStrategy || options.deleteBranch) {
+        repoConfig.prOptions = {
+            ...repoConfig.prOptions,
+            merge: options.merge ?? repoConfig.prOptions?.merge,
+            mergeStrategy: options.mergeStrategy ?? repoConfig.prOptions?.mergeStrategy,
+            deleteBranch: options.deleteBranch ?? repoConfig.prOptions?.deleteBranch,
+        };
+    }
+    const mergeMode = repoConfig.prOptions?.merge ?? "auto";
+    if (mergeMode === "direct" && repoConfig.prOptions?.mergeStrategy) {
+        logger.warn(`mergeStrategy '${repoConfig.prOptions.mergeStrategy}' is ignored in direct mode for ${repoConfig.git}`);
+    }
+    let repoInfo;
+    try {
+        repoInfo = parseGitUrl(repoConfig.git, {
+            githubHosts: config.githubHosts,
+        });
+    }
+    catch (error) {
+        logger.error(current, repoConfig.git, toErrorMessage(error));
+        ctx.reportResults.push({
+            repoName: repoConfig.git,
+            success: false,
+            fileChanges: [],
+            error: toErrorMessage(error),
+        });
+        return;
+    }
+    const repoName = getRepoDisplayName(repoInfo);
+    const workDir = resolve(join(options.workDir ?? "./tmp", generateWorkspaceName(index)));
+    const repoToken = isGitHubRepo(repoInfo)
+        ? (await resolveGitHubToken(repoInfo, ctx.tokenManager, repoName, logger, process.env.GH_TOKEN)).token
+        : undefined;
+    const skipFileSync = await runLifecyclePhase(repoConfig, repoInfo, repoName, index, workDir, repoToken, ctx);
+    if (skipFileSync)
+        return;
+    // Sync files via processor
+    await runFileSyncPhase(repoConfig, repoInfo, repoName, current, workDir, repoToken, ctx);
+    // Apply settings via API (GitHub-only — ADO and GitLab repos are skipped)
+    await applyRepoSettings({
+        repoConfig,
+        repoInfo,
+        repoName,
+        current,
+        options,
+        token: repoToken,
+        settingsCollector: ctx.settingsCollector,
+        rulesetProcessorFactory: ctx.rulesetProcessorFactory,
+        repoSettingsProcessorFactory: ctx.repoSettingsProcessorFactory,
+        labelsProcessorFactory: ctx.labelsProcessorFactory,
+    });
+}
+/**
+ * Run lifecycle check (repo existence, creation, forking).
+ * Returns true if the main loop should skip file sync for this repo.
+ */
+async function runLifecyclePhase(repoConfig, repoInfo, repoName, index, workDir, lifecycleToken, ctx) {
+    const current = index + 1;
+    try {
+        const { outputLines, lifecycleResult } = await runLifecycleCheck(repoConfig, repoInfo, index, {
+            dryRun: ctx.options.dryRun ?? false,
+            resolvedWorkDir: workDir,
+            githubHosts: ctx.config.githubHosts,
+            token: lifecycleToken,
+        }, ctx.lifecycleManager, ctx.config.settings?.repo);
+        for (const line of outputLines) {
+            logger.info(line);
+        }
+        const createSettings = toCreateRepoSettings(ctx.config.settings?.repo);
+        ctx.lifecycleReportInputs.push({
+            repoName,
+            action: lifecycleResult.action,
+            upstream: repoConfig.upstream,
+            source: repoConfig.source,
+            settings: createSettings
+                ? {
+                    visibility: createSettings.visibility,
+                    description: createSettings.description,
+                }
+                : undefined,
+        });
+        // In dry-run, skip processing repos that don't exist yet
+        if (ctx.options.dryRun && lifecycleResult.action !== "existed") {
+            ctx.reportResults.push({
+                repoName,
+                success: true,
+                fileChanges: [],
+            });
+            return true;
+        }
+        return false;
+    }
+    catch (error) {
+        logger.error(current, repoName, `Lifecycle error: ${toErrorMessage(error)}`);
+        ctx.reportResults.push({
+            repoName,
+            success: false,
+            fileChanges: [],
+            error: toErrorMessage(error),
+        });
+        return true;
+    }
+}
+/**
+ * Run the file sync processor for a single repo and collect results.
+ */
+async function runFileSyncPhase(repoConfig, repoInfo, repoName, current, workDir, token, ctx) {
+    try {
+        logger.progress(current, repoName, "Processing...");
+        const result = await ctx.processor.process(repoConfig, repoInfo, {
+            branchName: ctx.branchName,
+            workDir,
+            configId: ctx.config.id,
+            dryRun: ctx.options.dryRun,
+            retries: ctx.options.retries,
+            prTemplate: ctx.config.prTemplate,
+            noDelete: ctx.options.noDelete,
+            token,
+            isGraphQLCommitMode: isGitHubRepo(repoInfo) && ctx.tokenManager !== null,
+        });
+        const mergeOutcome = determineMergeOutcome(result);
+        ctx.reportResults.push({
+            repoName,
+            success: result.success,
+            fileChanges: (result.fileChanges ?? []).map((f) => ({
+                path: f.path,
+                action: f.action,
+            })),
+            prUrl: result.prUrl,
+            mergeOutcome,
+            error: result.success ? undefined : result.message,
+        });
+        if (result.skipped) {
+            logger.skip(current, repoName, result.message);
+        }
+        else if (result.success) {
+            logger.success(current, repoName, result.message);
+        }
+        else {
+            logger.error(current, repoName, result.message);
+        }
+    }
+    catch (error) {
+        logger.error(current, repoName, toErrorMessage(error));
+        ctx.reportResults.push({
+            repoName,
+            success: false,
+            fileChanges: [],
+            error: toErrorMessage(error),
+        });
+    }
+}
+export async function runSync(options, deps = {}) {
+    const { processorFactory = defaultProcessorFactory, lifecycleManager, rulesetProcessorFactory = defaultRulesetProcessorFactory, repoSettingsProcessorFactory = defaultRepoSettingsProcessorFactory, labelsProcessorFactory = defaultLabelsProcessorFactory, } = deps;
+    const configPath = resolve(options.config);
+    if (!existsSync(configPath)) {
+        throw new Error(`Config file not found: ${configPath}`);
+    }
+    logger.log(`Loading config from: ${configPath}`);
+    if (options.dryRun) {
+        logger.log("Running in DRY RUN mode - no changes will be made\n");
+    }
+    const rawConfig = loadRawConfig(configPath);
+    validateForSync(rawConfig);
+    const config = normalizeConfig(rawConfig);
+    const fileNames = getUniqueFileNames(config);
+    let branchName;
+    if (options.branch) {
+        validateBranchName(options.branch);
+        branchName = options.branch;
+    }
+    else {
+        branchName = generateBranchName(fileNames);
+    }
+    logger.setTotal(config.repos.length);
+    logger.log(`Found ${config.repos.length} repositories to process`);
+    logger.log(`Target files: ${formatFileNames(fileNames)}`);
+    logger.log(`Branch: ${branchName}\n`);
+    const ctx = {
+        config,
+        options,
+        branchName,
+        processor: processorFactory(),
+        lifecycleManager: lifecycleManager ?? new RepoLifecycleManager(undefined, options.retries),
+        tokenManager: createTokenManager(),
+        reportResults: [],
+        lifecycleReportInputs: [],
+        settingsCollector: new ResultsCollector(),
+        rulesetProcessorFactory,
+        repoSettingsProcessorFactory,
+        labelsProcessorFactory,
+    };
+    for (let i = 0; i < config.repos.length; i++) {
+        await processSingleRepo(config.repos[i], i, ctx);
+    }
+    displayReports(ctx.reportResults, ctx.lifecycleReportInputs, ctx.settingsCollector, options.dryRun ?? false);
+    // Propagate failures to caller (CLI entry handles process.exit)
+    const settingsResults = ctx.settingsCollector.getAll();
+    const hasErrors = ctx.reportResults.some((r) => r.error);
+    const hasSettingsErrors = settingsResults.some((r) => r.error);
+    if (hasErrors || hasSettingsErrors) {
+        throw new Error("One or more repositories had errors during sync");
     }
 }