@aspruyt/xfg 6.1.0 → 6.3.0

package/dist/cli/settings-runner.js

@@ -0,0 +1,94 @@
+import { isGitHubRepo } from "../repo/index.js";
+import { toErrorMessage } from "../shared/type-guards.js";
+function logSettingsResult(logger, result, label, repoNumber, repoName, settingsCollector) {
+    if (result.planOutput?.lines?.length) {
+        logger.info("");
+        logger.info(`${repoName} - ${label}:`);
+        for (const line of result.planOutput.lines) {
+            logger.info(line);
+        }
+        if (result.warnings?.length) {
+            for (const warning of result.warnings) {
+                logger.warn(warning);
+            }
+        }
+    }
+    else if (!result.skipped && result.success) {
+        logger.success(repoNumber, repoName, `${label}: ${result.message}`);
+    }
+    if (!result.success && !result.skipped) {
+        logger.error(repoNumber, repoName, `${label}: ${result.message}`);
+        settingsCollector.appendError(repoName, result.message);
+    }
+}
+async function runAndStoreResult(factory, repoConfig, repoInfo, opts, repoName, settingsCollector, assign) {
+    const result = await factory().process(repoConfig, repoInfo, opts);
+    if (!result.skipped) {
+        assign(settingsCollector.findOrCreate(repoName), result);
+    }
+    return result;
+}
+function buildSettingsDescriptors(ctx) {
+    const { repoConfig, repoInfo, options, token, repoName, settingsCollector } = ctx;
+    const { factories } = ctx;
+    const sharedOpts = {
+        dryRun: options.dryRun,
+        noDelete: options.noDelete,
+        token,
+    };
+    return [
+        {
+            key: "rulesets",
+            label: "Rulesets",
+            run: () => runAndStoreResult(factories.rulesets, repoConfig, repoInfo, sharedOpts, repoName, settingsCollector, (e, r) => {
+                e.rulesetResult = r;
+            }),
+        },
+        {
+            key: "labels",
+            label: "Labels",
+            run: () => runAndStoreResult(factories.labels, repoConfig, repoInfo, sharedOpts, repoName, settingsCollector, (e, r) => {
+                e.labelsResult = r;
+            }),
+        },
+        {
+            key: "repo",
+            label: "Repo Settings",
+            run: () => runAndStoreResult(factories.repo, repoConfig, repoInfo, { dryRun: options.dryRun, token }, repoName, settingsCollector, (e, r) => {
+                e.settingsResult = r;
+            }),
+        },
+        {
+            key: "codeScanning",
+            label: "Code Scanning",
+            run: () => runAndStoreResult(factories.codeScanning, repoConfig, repoInfo, sharedOpts, repoName, settingsCollector, (e, r) => {
+                e.codeScanningResult = r;
+            }),
+        },
+        {
+            key: "variables",
+            label: "Variables",
+            run: () => runAndStoreResult(factories.variables, repoConfig, repoInfo, sharedOpts, repoName, settingsCollector, (e, r) => {
+                e.variablesResult = r;
+            }),
+        },
+    ];
+}
+export async function applyRepoSettings(ctx) {
+    const { repoConfig, repoInfo, repoName, repoNumber, settingsCollector, logger, } = ctx;
+    if (!repoConfig.settings || !isGitHubRepo(repoInfo))
+        return;
+    for (const desc of buildSettingsDescriptors(ctx)) {
+        const settingsValue = repoConfig.settings[desc.key];
+        if (!settingsValue || Object.keys(settingsValue).length === 0)
+            continue;
+        try {
+            const result = await desc.run();
+            logSettingsResult(logger, result, desc.label, repoNumber, repoName, settingsCollector);
+        }
+        catch (error) {
+            logger.error(repoNumber, repoName, `${desc.label}: ${toErrorMessage(error)}`);
+            settingsCollector.appendError(repoName, error);
+        }
+    }
+}

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

@@ -1,3 +1,3 @@
-import { type SyncDependencies, type SyncOptions } from "./types.js";
+import type { SyncDependencies, 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,209 +1,47 @@
-import { resolve, join } from "node:path";
+import { resolve } from "node:path";
 import { existsSync } from "node:fs";
 import { loadRawConfig, normalizeConfig, validateForSync, } from "../config/index.js";
 import { ValidationError, SyncError } from "../shared/errors.js";
-import { parseGitUrl, getRepoDisplayName, isGitHubRepo, } from "../repo/index.js";
-import { sanitizeBranchName, validateBranchName } from "./branch-utils.js";
+import { validateBranchName } from "./branch-utils.js";
 import { createTokenManager } from "../vcs/index.js";
 import { RepositoryProcessor } from "../sync/index.js";
-import { RulesetProcessor, RepoSettingsProcessor, LabelsProcessor, CodeScanningProcessor, GitHubRulesetStrategy, GitHubRepoSettingsStrategy, GitHubLabelsStrategy, GitHubCodeScanningStrategy, } from "../settings/index.js";
-import { GitHubRepoMetadataProvider } from "../repo/index.js";
-import { ShellCommandExecutor } from "../shared/command-executor.js";
+import { ProcessExecutor } from "../shared/command-executor.js";
 import { Logger } from "../shared/logger.js";
-import { generateWorkspaceName } from "../shared/workspace-utils.js";
-let _defaultExecutor;
-let _logger;
-function getDefaultExecutor() {
-    return (_defaultExecutor ??= new ShellCommandExecutor(process.env));
-}
-function getLogger() {
-    return (_logger ??= new Logger(!!(process.env.DEBUG || process.env.XFG_DEBUG)));
-}
-function createDefaultRulesetProcessorFactory() {
-    const cwd = process.cwd();
-    return () => new RulesetProcessor(new GitHubRulesetStrategy(getDefaultExecutor(), { cwd }));
-}
-function createDefaultRepoSettingsProcessorFactory() {
-    const cwd = process.cwd();
-    const executor = getDefaultExecutor();
-    return () => new RepoSettingsProcessor(new GitHubRepoSettingsStrategy(executor, { cwd }), new GitHubRepoMetadataProvider(executor, { cwd }));
-}
-function createDefaultLabelsProcessorFactory() {
-    const cwd = process.cwd();
-    return () => new LabelsProcessor(new GitHubLabelsStrategy(getDefaultExecutor(), { cwd }));
-}
-function createDefaultCodeScanningProcessorFactory() {
-    const cwd = process.cwd();
-    const executor = getDefaultExecutor();
-    return () => new CodeScanningProcessor(new GitHubCodeScanningStrategy(executor, { cwd }), new GitHubRepoMetadataProvider(executor, { cwd }));
-}
 import { ResultsCollector } from "./results-collector.js";
-import { buildSettingsReport, } from "./settings-report-builder.js";
-import { formatSettingsReportCLI } from "../output/settings-report.js";
+import { buildSettingsReport } from "./settings-report-builder.js";
+import { formatSettingsReportCLI, formatSyncReportCLI, formatLifecycleReportCLI, hasLifecycleChanges, } from "../output/index.js";
 import { buildSyncReport } from "./sync-report-builder.js";
-import { formatSyncReportCLI } from "../output/sync-report.js";
 import { buildLifecycleReport } from "./lifecycle-report-builder.js";
-import { formatLifecycleReportCLI, hasLifecycleChanges, } from "../output/lifecycle-report.js";
 import { writeUnifiedSummary } from "./unified-summary.js";
-import { toErrorMessage } from "../shared/type-guards.js";
-import { resolveGitHubToken } from "../shared/gh-api-utils.js";
-import { RepoLifecycleManager, runLifecycleCheck, } from "../lifecycle/index.js";
-function getUniqueFileNames(config) {
-    const fileNames = new Set();
-    for (const repo of config.repos) {
-        for (const file of repo.files) {
-            fileNames.add(file.fileName);
-        }
-    }
-    return Array.from(fileNames);
-}
-function generateBranchName(fileNames) {
-    if (fileNames.length === 1) {
-        return `chore/sync-${sanitizeBranchName(fileNames[0])}`;
-    }
-    return "chore/sync-config";
-}
-function formatFileNames(fileNames) {
-    if (fileNames.length === 1) {
-        return fileNames[0];
-    }
-    if (fileNames.length <= 3) {
-        return fileNames.join(", ");
-    }
-    return `${fileNames.length} files`;
-}
-function determineMergeOutcome(result) {
-    if (!result.success)
-        return undefined;
-    if (!result.prUrl)
-        return "direct";
-    if (result.mergeResult?.merged)
-        return "force";
-    if (result.mergeResult?.autoMergeEnabled)
-        return "auto";
-    return "manual";
-}
-function logSettingsResult(result, label, repoNumber, repoName, settingsCollector) {
-    if (result.planOutput?.lines?.length) {
-        getLogger().info("");
-        getLogger().info(`${repoName} - ${label}:`);
-        for (const line of result.planOutput.lines) {
-            getLogger().info(line);
-        }
-        if (result.warnings?.length) {
-            for (const warning of result.warnings) {
-                getLogger().warn(warning);
-            }
-        }
-    }
-    else if (!result.skipped && result.success) {
-        getLogger().success(repoNumber, repoName, `${label}: ${result.message}`);
-    }
-    if (!result.success && !result.skipped) {
-        getLogger().error(repoNumber, repoName, `${label}: ${result.message}`);
-        settingsCollector.appendError(repoName, result.message);
-    }
-}
-// Each processor returns a subtype of BaseProcessorResult whose planOutput
-// contains both `lines` (for CLI display) and `entries` (for report building).
-// ProcessorResults fields capture only the `entries` slice; the runtime object
-// satisfies both views, so we assign with an explicit per-field cast.
-async function runAndStoreResult(factory, repoConfig, repoInfo, opts, repoName, settingsCollector, assign) {
-    const result = await runSettingsProcessor(factory, repoConfig, repoInfo, opts);
-    if (!result.skipped) {
-        assign(settingsCollector.getOrCreate(repoName), result);
-    }
-    return result;
-}
-function buildSettingsDescriptors(ctx) {
-    const { repoConfig, repoInfo, options, token, repoName, settingsCollector } = ctx;
-    const { factories } = ctx;
-    const sharedOpts = {
-        dryRun: options.dryRun,
-        noDelete: options.noDelete,
-        token,
-    };
-    return [
-        {
-            key: "rulesets",
-            label: "Rulesets",
-            run: () => runAndStoreResult(factories.rulesets, repoConfig, repoInfo, sharedOpts, repoName, settingsCollector, (e, r) => {
-                e.rulesetResult = r;
-            }),
-        },
-        {
-            key: "labels",
-            label: "Labels",
-            run: () => runAndStoreResult(factories.labels, repoConfig, repoInfo, sharedOpts, repoName, settingsCollector, (e, r) => {
-                e.labelsResult = r;
-            }),
-        },
-        {
-            key: "repo",
-            label: "Repo Settings",
-            run: () => runAndStoreResult(factories.repo, repoConfig, repoInfo, { dryRun: options.dryRun, token }, repoName, settingsCollector, (e, r) => {
-                e.settingsResult = r;
-            }),
-        },
-        {
-            key: "codeScanning",
-            label: "Code Scanning",
-            run: () => runAndStoreResult(factories.codeScanning, repoConfig, repoInfo, sharedOpts, repoName, settingsCollector, (e, r) => {
-                e.codeScanningResult = r;
-            }),
-        },
-    ];
-}
-function runSettingsProcessor(factory, repoConfig, repoInfo, processOptions) {
-    return factory()
-        .process(repoConfig, repoInfo, processOptions)
-        .then((result) => result);
-}
-async function applyRepoSettings(ctx) {
-    const { repoConfig, repoInfo, repoName, repoNumber, settingsCollector } = ctx;
-    if (!repoConfig.settings || !isGitHubRepo(repoInfo))
-        return;
-    for (const desc of buildSettingsDescriptors(ctx)) {
-        const settingsValue = repoConfig.settings[desc.key];
-        if (!settingsValue || Object.keys(settingsValue).length === 0)
-            continue;
-        try {
-            const result = await desc.run();
-            logSettingsResult(result, desc.label, repoNumber, repoName, settingsCollector);
-        }
-        catch (error) {
-            getLogger().error(repoNumber, repoName, `${desc.label}: ${toErrorMessage(error)}`);
-            settingsCollector.appendError(repoName, error);
-        }
-    }
-}
-function displayReports(reportResults, lifecycleReportInputs, settingsCollector, dryRun) {
+import { RepoLifecycleManager } from "../lifecycle/index.js";
+import { createDefaultFactories } from "./settings-factories.js";
+import { getUniqueFileNames, generateBranchName, formatFileNames, } from "./sync-utils.js";
+import { runSingleRepo, } from "./repo-sync-runner.js";
+function displayReports(logger, reportResults, lifecycleReportInputs, settingsCollector, dryRun) {
     const lifecycleReport = buildLifecycleReport(lifecycleReportInputs);
     if (hasLifecycleChanges(lifecycleReport)) {
-        getLogger().log("");
+        logger.log("");
         for (const line of formatLifecycleReportCLI(lifecycleReport)) {
-            getLogger().log(line);
+            logger.log(line);
         }
     }
     const report = buildSyncReport(reportResults);
-    getLogger().log("");
+    logger.log("");
     for (const line of formatSyncReportCLI(report)) {
-        getLogger().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) {
-            getLogger().log("");
+            logger.log("");
             for (const line of settingsLines) {
-                getLogger().log(line);
+                logger.log(line);
             }
         }
     }
-    // Write unified summary to GITHUB_STEP_SUMMARY
     writeUnifiedSummary({
         lifecycle: lifecycleReport,
         sync: report,
@@ -212,198 +50,18 @@ function displayReports(reportResults, lifecycleReportInputs, settingsCollector,
         summaryPath: process.env.GITHUB_STEP_SUMMARY,
     });
 }
-function pushFailure(results, repoName, error) {
-    results.push({
-        repoName,
-        success: false,
-        fileChanges: [],
-        error: toErrorMessage(error),
-    });
-}
-/**
- * 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 repoNumber = 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) {
-        getLogger().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) {
-        getLogger().error(repoNumber, repoConfig.git, toErrorMessage(error));
-        pushFailure(ctx.reportResults, repoConfig.git, error);
-        return;
-    }
-    const repoName = getRepoDisplayName(repoInfo);
-    const workDir = resolve(join(options.workDir ?? "./tmp", generateWorkspaceName(index)));
-    const repoToken = isGitHubRepo(repoInfo)
-        ? (await resolveGitHubToken({
-            repoInfo: repoInfo,
-            tokenManager: ctx.tokenManager,
-            context: repoName,
-            log: getLogger(),
-            envToken: process.env.GH_TOKEN,
-        })).token
-        : undefined;
-    const repo = {
-        repoConfig,
-        repoInfo,
-        repoName,
-        index,
-        workDir,
-        token: repoToken,
-    };
-    const skipFileSync = await runLifecyclePhase(repo, ctx);
-    if (skipFileSync)
-        return;
-    // Sync files via processor
-    await runFileSyncPhase(repo, ctx);
-    // Apply settings via API (GitHub-only — ADO and GitLab repos are skipped)
-    await applyRepoSettings({
-        repoConfig,
-        repoInfo,
-        repoName,
-        repoNumber,
-        options,
-        token: repoToken,
-        settingsCollector: ctx.settingsCollector,
-        factories: ctx.factories,
-    });
-}
-/**
- * Run lifecycle check (repo existence, creation, forking).
- * Returns true if the main loop should skip file sync for this repo.
- */
-async function runLifecyclePhase(repo, ctx) {
-    const repoNumber = repo.index + 1;
-    try {
-        const { outputLines, lifecycleResult, createSettings } = await runLifecycleCheck(repo.repoConfig, repo.repoInfo, {
-            dryRun: ctx.options.dryRun ?? false,
-            resolvedWorkDir: repo.workDir,
-            githubHosts: ctx.config.githubHosts,
-            token: repo.token,
-            repoIndex: repo.index,
-            lifecycleManager: ctx.lifecycleManager,
-            repoSettings: ctx.config.settings?.repo,
-        });
-        for (const line of outputLines) {
-            getLogger().info(line);
-        }
-        ctx.lifecycleReportInputs.push({
-            repoName: repo.repoName,
-            action: lifecycleResult.action,
-            upstream: repo.repoConfig.upstream,
-            source: repo.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: repo.repoName,
-                success: true,
-                fileChanges: [],
-            });
-            return true;
-        }
-        return false;
-    }
-    catch (error) {
-        getLogger().error(repoNumber, repo.repoName, `Lifecycle error: ${toErrorMessage(error)}`);
-        pushFailure(ctx.reportResults, repo.repoName, error);
-        return true;
-    }
-}
-/**
- * Run the file sync processor for a single repo and collect results.
- */
-async function runFileSyncPhase(repo, ctx) {
-    const repoNumber = repo.index + 1;
-    try {
-        getLogger().progress(repoNumber, repo.repoName, "Processing...");
-        const result = await ctx.processor.process(repo.repoConfig, repo.repoInfo, {
-            branchName: ctx.branchName,
-            workDir: repo.workDir,
-            configId: ctx.config.id,
-            dryRun: ctx.options.dryRun,
-            retries: ctx.options.retries,
-            executor: getDefaultExecutor(),
-            prTemplate: ctx.config.prTemplate,
-            noDelete: ctx.options.noDelete,
-            token: repo.token,
-            hasAppCredentials: isGitHubRepo(repo.repoInfo) && ctx.tokenManager !== null,
-        });
-        const mergeOutcome = determineMergeOutcome(result);
-        ctx.reportResults.push({
-            repoName: repo.repoName,
-            success: result.success,
-            fileChanges: (result.fileChanges ?? []).map((f) => ({
-                path: f.path,
-                action: f.action,
-                ...(f.diffLines ? { diffLines: f.diffLines } : {}),
-            })),
-            prUrl: result.prUrl,
-            mergeOutcome,
-            error: result.success ? undefined : result.message,
-        });
-        if (result.skipped) {
-            getLogger().skip(repoNumber, repo.repoName, result.message);
-        }
-        else if (result.success) {
-            getLogger().success(repoNumber, repo.repoName, result.message);
-        }
-        else {
-            getLogger().error(repoNumber, repo.repoName, result.message);
-        }
-    }
-    catch (error) {
-        getLogger().error(repoNumber, repo.repoName, toErrorMessage(error));
-        pushFailure(ctx.reportResults, repo.repoName, error);
-    }
-}
 export async function runSync(options, deps = {}) {
-    // Reset module-level singletons to ensure fresh state per invocation
-    _defaultExecutor = undefined;
-    _logger = undefined;
+    const executor = new ProcessExecutor(process.env);
+    const logger = new Logger(!!(process.env.DEBUG || process.env.XFG_DEBUG));
     const { lifecycleManager, settingsProcessorFactories } = deps;
-    const factories = {
-        rulesets: settingsProcessorFactories?.rulesets ??
-            createDefaultRulesetProcessorFactory(),
-        labels: settingsProcessorFactories?.labels ??
-            createDefaultLabelsProcessorFactory(),
-        repo: settingsProcessorFactories?.repo ??
-            createDefaultRepoSettingsProcessorFactory(),
-        codeScanning: settingsProcessorFactories?.codeScanning ??
-            createDefaultCodeScanningProcessorFactory(),
-    };
+    const factories = createDefaultFactories(executor, settingsProcessorFactories);
     const configPath = resolve(options.config);
     if (!existsSync(configPath)) {
         throw new ValidationError(`Config path not found: ${configPath}`);
     }
-    getLogger().log(`Loading config from: ${configPath}`);
+    logger.log(`Loading config from: ${configPath}`);
     if (options.dryRun) {
-        getLogger().log("Running in DRY RUN mode - no changes will be made\n");
+        logger.log("Running in DRY RUN mode - no changes will be made\n");
     }
     const rawConfig = loadRawConfig(configPath);
     validateForSync(rawConfig);
@@ -417,10 +75,10 @@ export async function runSync(options, deps = {}) {
     else {
         branchName = generateBranchName(fileNames);
     }
-    getLogger().setTotal(config.repos.length);
-    getLogger().log(`Found ${config.repos.length} repositories to process`);
-    getLogger().log(`Target files: ${formatFileNames(fileNames)}`);
-    getLogger().log(`Branch: ${branchName}\n`);
+    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 tokenManager = createTokenManager(process.env.XFG_GITHUB_CLIENT_ID && process.env.XFG_GITHUB_APP_PRIVATE_KEY
         ? {
             clientId: process.env.XFG_GITHUB_CLIENT_ID,
@@ -429,7 +87,7 @@ export async function runSync(options, deps = {}) {
         : undefined);
     const processor = deps.processorFactory
         ? deps.processorFactory()
-        : new RepositoryProcessor(undefined, getLogger(), {
+        : new RepositoryProcessor(undefined, logger, {
             tokenManager,
             envToken: process.env.GH_TOKEN,
         });
@@ -439,18 +97,19 @@ export async function runSync(options, deps = {}) {
         branchName,
         processor,
         lifecycleManager: lifecycleManager ??
-            new RepoLifecycleManager(undefined, getDefaultExecutor(), options.retries, process.cwd(), getLogger()),
+            new RepoLifecycleManager(undefined, executor, options.retries, process.cwd(), logger),
         tokenManager,
         reportResults: [],
         lifecycleReportInputs: [],
         settingsCollector: new ResultsCollector(),
         factories,
+        logger,
+        executor,
     };
     for (let i = 0; i < config.repos.length; i++) {
-        await processSingleRepo(config.repos[i], i, ctx);
+        await runSingleRepo(config.repos[i], i, ctx);
     }
-    displayReports(ctx.reportResults, ctx.lifecycleReportInputs, ctx.settingsCollector, options.dryRun ?? false);
-    // Propagate failures to caller (CLI entry handles process.exit)
+    displayReports(logger, ctx.reportResults, ctx.lifecycleReportInputs, ctx.settingsCollector, options.dryRun ?? false);
     const settingsResults = ctx.settingsCollector.getAll();
     const hasErrors = ctx.reportResults.some((r) => r.error);
     const hasSettingsErrors = settingsResults.some((r) => r.error);

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

@@ -1,5 +1,5 @@
 import type { MergeMode } from "../config/index.js";
-import type { SyncReport, ReportFileChange } from "../output/sync-report.js";
+import type { SyncReport, ReportFileChange } from "../output/index.js";
 interface SyncResultInput {
     repoName: string;
     success: boolean;

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

@@ -0,0 +1,8 @@
+import type { RepoConfig, MergeMode } from "../config/index.js";
+import type { ProcessorResult } from "../sync/index.js";
+export declare function getUniqueFileNames(config: {
+    repos: RepoConfig[];
+}): string[];
+export declare function generateBranchName(fileNames: string[]): string;
+export declare function formatFileNames(fileNames: string[]): string;
+export declare function determineMergeOutcome(result: ProcessorResult): MergeMode | undefined;

package/dist/cli/sync-utils.js

@@ -0,0 +1,36 @@
+import { sanitizeBranchName } from "./branch-utils.js";
+export function getUniqueFileNames(config) {
+    const fileNames = new Set();
+    for (const repo of config.repos) {
+        for (const file of repo.files) {
+            fileNames.add(file.fileName);
+        }
+    }
+    return Array.from(fileNames);
+}
+export function generateBranchName(fileNames) {
+    if (fileNames.length === 1) {
+        return `chore/sync-${sanitizeBranchName(fileNames[0])}`;
+    }
+    return "chore/sync-config";
+}
+export function formatFileNames(fileNames) {
+    if (fileNames.length === 1) {
+        return fileNames[0];
+    }
+    if (fileNames.length <= 3) {
+        return fileNames.join(", ");
+    }
+    return `${fileNames.length} files`;
+}
+export function determineMergeOutcome(result) {
+    if (!result.success)
+        return undefined;
+    if (!result.prUrl)
+        return "direct";
+    if (result.mergeResult?.merged)
+        return "force";
+    if (result.mergeResult?.autoMergeEnabled)
+        return "auto";
+    return "manual";
+}

package/dist/cli/types.d.ts

@@ -1,21 +1,24 @@
 import type { MergeMode, MergeStrategy, RepoConfig } from "../config/index.js";
 import type { IRepoLifecycleManager } from "../lifecycle/index.js";
-import type { IRepositoryProcessor } from "../sync/index.js";
-import type { ISettingsProcessor, IRulesetProcessor, IRepoSettingsProcessor, ILabelsProcessor, ICodeScanningProcessor, BaseProcessorResult, ActiveAction } from "../settings/index.js";
+import type { IRepositoryProcessor, FileChangeDetail } from "../sync/index.js";
+import type { ISettingsProcessor, IRulesetProcessor, IRepoSettingsProcessor, ILabelsProcessor, ICodeScanningProcessor, IVariablesProcessor, BaseProcessorResult } from "../settings/index.js";
 import type { RepoInfo } from "../repo/index.js";
 import type { ResultsCollector } from "./results-collector.js";
+import type { Logger } from "../shared/logger.js";
 export type ProcessorFactory = () => IRepositoryProcessor;
 export type SettingsProcessorFactory<T extends ISettingsProcessor> = () => T;
 export type RulesetProcessorFactory = SettingsProcessorFactory<IRulesetProcessor>;
 export type RepoSettingsProcessorFactory = SettingsProcessorFactory<IRepoSettingsProcessor>;
 export type LabelsProcessorFactory = SettingsProcessorFactory<ILabelsProcessor>;
 export type CodeScanningProcessorFactory = SettingsProcessorFactory<ICodeScanningProcessor>;
-export type SettingsKind = "rulesets" | "labels" | "repo" | "codeScanning";
+export type VariablesProcessorFactory = SettingsProcessorFactory<IVariablesProcessor>;
+export type SettingsKind = "rulesets" | "labels" | "repo" | "codeScanning" | "variables";
 export interface SettingsProcessorFactories {
     rulesets: RulesetProcessorFactory;
     labels: LabelsProcessorFactory;
     repo: RepoSettingsProcessorFactory;
     codeScanning: CodeScanningProcessorFactory;
+    variables: VariablesProcessorFactory;
 }
 /**
  * Dependencies for the sync command (dependency injection).
@@ -41,11 +44,7 @@ export interface SyncOptions extends SharedOptions {
 export interface SyncResultEntry {
     repoName: string;
     success: boolean;
-    fileChanges: Array<{
-        path: string;
-        action: ActiveAction;
-        diffLines?: string[];
-    }>;
+    fileChanges: FileChangeDetail[];
     prUrl?: string;
     mergeOutcome?: MergeMode;
     error?: string;
@@ -69,4 +68,5 @@ export interface ApplyRepoSettingsContext {
     token: string | undefined;
     settingsCollector: ResultsCollector;
     factories: SettingsProcessorFactories;
+    logger: Logger;
 }