@aspruyt/xfg 6.0.3 → 6.2.0

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

@@ -1,2 +1,2 @@
-import type { LifecycleReport, LifecycleAction } from "../output/lifecycle-report.js";
-export declare function buildLifecycleReport(results: LifecycleAction[]): LifecycleReport;
+import type { LifecycleReport, LifecycleAction } from "../output/index.js";
+export declare function buildLifecycleReport(actions: LifecycleAction[]): LifecycleReport;

package/dist/cli/lifecycle-report-builder.js

@@ -1,15 +1,7 @@
-export function buildLifecycleReport(results) {
-    const actions = [];
+export function buildLifecycleReport(actions) {
     const totals = { created: 0, forked: 0, migrated: 0, existed: 0 };
-    for (const result of results) {
-        actions.push({
-            repoName: result.repoName,
-            action: result.action,
-            upstream: result.upstream,
-            source: result.source,
-            settings: result.settings,
-        });
-        totals[result.action]++;
+    for (const action of actions) {
+        totals[action.action]++;
     }
     return { actions, totals };
 }

package/dist/cli/program.d.ts

@@ -1,5 +1,6 @@
 import { program } from "commander";
 import { MergeMode, MergeStrategy } from "../config/index.js";
+declare function getVersion(): string;
 export declare function parseMergeMode(value: string): MergeMode;
 export declare function parseMergeStrategy(value: string): MergeStrategy;
-export { program };
+export { program, getVersion };

package/dist/cli/program.js

@@ -51,8 +51,7 @@ export function parseMergeStrategy(value) {
 // =============================================================================
 program
     .name("xfg")
-    .description("Manage files, settings, and repositories across GitHub, Azure DevOps, and GitLab")
-    .version(getVersion());
+    .description("Manage files, settings, and repositories across GitHub, Azure DevOps, and GitLab");
 // Sync command (file synchronization)
 const syncCommand = new Command("sync")
     .description("Sync configuration files across repositories")
@@ -71,4 +70,4 @@ const syncCommand = new Command("sync")
 });
 addSharedOptions(syncCommand);
 program.addCommand(syncCommand);
-export { program };
+export { program, getVersion };

package/dist/cli/repo-sync-runner.d.ts

@@ -0,0 +1,24 @@
+import type { Config, RepoConfig } from "../config/index.js";
+import type { createTokenManager } from "../vcs/index.js";
+import type { IRepositoryProcessor } from "../sync/index.js";
+import type { ProcessExecutor } from "../shared/command-executor.js";
+import type { Logger } from "../shared/logger.js";
+import { type IRepoLifecycleManager } from "../lifecycle/index.js";
+import type { SyncOptions, SyncResultEntry, SettingsProcessorFactories } from "./types.js";
+import type { ResultsCollector } from "./results-collector.js";
+import type { LifecycleAction } from "../output/index.js";
+export interface RepoIterationContext {
+    config: Config;
+    options: SyncOptions;
+    branchName: string;
+    processor: IRepositoryProcessor;
+    lifecycleManager: IRepoLifecycleManager;
+    tokenManager: ReturnType<typeof createTokenManager>;
+    reportResults: SyncResultEntry[];
+    lifecycleReportInputs: LifecycleAction[];
+    settingsCollector: ResultsCollector;
+    factories: SettingsProcessorFactories;
+    logger: Logger;
+    executor: ProcessExecutor;
+}
+export declare function runSingleRepo(repoConfig: RepoConfig, index: number, ctx: RepoIterationContext): Promise<void>;

package/dist/cli/repo-sync-runner.js

@@ -0,0 +1,156 @@
+import { resolve, join } from "node:path";
+import { parseGitUrl, getRepoDisplayName, isGitHubRepo, } from "../repo/index.js";
+import { generateWorkspaceName } from "../shared/workspace-utils.js";
+import { toErrorMessage } from "../shared/type-guards.js";
+import { resolveGitHubToken } from "../shared/gh-token-utils.js";
+import { runLifecycleCheck, } from "../lifecycle/index.js";
+import { applyRepoSettings } from "./settings-runner.js";
+import { determineMergeOutcome } from "./sync-utils.js";
+function pushFailure(results, repoName, error) {
+    results.push({
+        repoName,
+        success: false,
+        fileChanges: [],
+        error: toErrorMessage(error),
+    });
+}
+async function runLifecyclePhase(repo, ctx) {
+    const repoNumber = repo.index + 1;
+    try {
+        const { outputLines, lifecycleResult, reportSettings } = 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) {
+            ctx.logger.info(line);
+        }
+        ctx.lifecycleReportInputs.push({
+            repoName: repo.repoName,
+            action: lifecycleResult.action,
+            upstream: repo.repoConfig.upstream,
+            source: repo.repoConfig.source,
+            settings: reportSettings,
+        });
+        if (ctx.options.dryRun && lifecycleResult.action !== "existed") {
+            ctx.reportResults.push({
+                repoName: repo.repoName,
+                success: true,
+                fileChanges: [],
+            });
+            return true;
+        }
+        return false;
+    }
+    catch (error) {
+        ctx.logger.error(repoNumber, repo.repoName, `Lifecycle error: ${toErrorMessage(error)}`);
+        pushFailure(ctx.reportResults, repo.repoName, error);
+        return true;
+    }
+}
+async function runFileSyncPhase(repo, ctx) {
+    const repoNumber = repo.index + 1;
+    try {
+        ctx.logger.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: ctx.executor,
+            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 ?? [],
+            prUrl: result.prUrl,
+            mergeOutcome,
+            error: result.success ? undefined : result.message,
+        });
+        if (result.skipped) {
+            ctx.logger.skip(repoNumber, repo.repoName, result.message);
+        }
+        else if (result.success) {
+            ctx.logger.success(repoNumber, repo.repoName, result.message);
+        }
+        else {
+            ctx.logger.error(repoNumber, repo.repoName, result.message);
+        }
+    }
+    catch (error) {
+        ctx.logger.error(repoNumber, repo.repoName, toErrorMessage(error));
+        pushFailure(ctx.reportResults, repo.repoName, error);
+    }
+}
+export async function runSingleRepo(repoConfig, index, ctx) {
+    const { config, options, logger } = ctx;
+    const repoNumber = index + 1;
+    const effectivePrOptions = options.merge || options.mergeStrategy || options.deleteBranch
+        ? {
+            ...repoConfig.prOptions,
+            merge: options.merge ?? repoConfig.prOptions?.merge,
+            mergeStrategy: options.mergeStrategy ?? repoConfig.prOptions?.mergeStrategy,
+            deleteBranch: options.deleteBranch ?? repoConfig.prOptions?.deleteBranch,
+        }
+        : repoConfig.prOptions;
+    const effectiveRepoConfig = { ...repoConfig, prOptions: effectivePrOptions };
+    const mergeMode = effectivePrOptions?.merge ?? "auto";
+    if (mergeMode === "direct" && effectivePrOptions?.mergeStrategy) {
+        logger.warn(`mergeStrategy '${effectivePrOptions.mergeStrategy}' is ignored in direct mode for ${repoConfig.git}`);
+    }
+    let repoInfo;
+    try {
+        repoInfo = parseGitUrl(repoConfig.git, {
+            githubHosts: config.githubHosts,
+        });
+    }
+    catch (error) {
+        logger.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: logger,
+            envToken: process.env.GH_TOKEN,
+        })).token
+        : undefined;
+    const repo = {
+        repoConfig: effectiveRepoConfig,
+        repoInfo,
+        repoName,
+        index,
+        workDir,
+        token: repoToken,
+    };
+    const skipFileSync = await runLifecyclePhase(repo, ctx);
+    if (skipFileSync)
+        return;
+    await runFileSyncPhase(repo, ctx);
+    await applyRepoSettings({
+        repoConfig: effectiveRepoConfig,
+        repoInfo,
+        repoName,
+        repoNumber,
+        options,
+        token: repoToken,
+        settingsCollector: ctx.settingsCollector,
+        factories: ctx.factories,
+        logger,
+    });
+}

package/dist/cli/results-collector.d.ts

@@ -5,7 +5,7 @@ import type { ProcessorResults } from "./settings-report-builder.js";
  */
 export declare class ResultsCollector {
     private readonly results;
-    getOrCreate(repoName: string): ProcessorResults;
+    findOrCreate(repoName: string): ProcessorResults;
     appendError(repoName: string, error: unknown): void;
     getAll(): ProcessorResults[];
 }

package/dist/cli/results-collector.js

@@ -5,7 +5,7 @@ import { toErrorMessage } from "../shared/type-guards.js";
  */
 export class ResultsCollector {
     results = [];
-    getOrCreate(repoName) {
+    findOrCreate(repoName) {
         let result = this.results.find((r) => r.repoName === repoName);
         if (!result) {
             result = { repoName };
@@ -14,7 +14,7 @@ export class ResultsCollector {
         return result;
     }
     appendError(repoName, error) {
-        const existing = this.getOrCreate(repoName);
+        const existing = this.findOrCreate(repoName);
         const errorMsg = toErrorMessage(error);
         if (existing.error) {
             existing.error += `; ${errorMsg}`;

package/dist/cli/settings-factories.d.ts

@@ -0,0 +1,7 @@
+import type { ProcessExecutor } from "../shared/command-executor.js";
+import type { RulesetProcessorFactory, RepoSettingsProcessorFactory, LabelsProcessorFactory, CodeScanningProcessorFactory, SettingsProcessorFactories } from "./types.js";
+export declare function createDefaultRulesetProcessorFactory(executor: ProcessExecutor): RulesetProcessorFactory;
+export declare function createDefaultRepoSettingsProcessorFactory(executor: ProcessExecutor): RepoSettingsProcessorFactory;
+export declare function createDefaultLabelsProcessorFactory(executor: ProcessExecutor): LabelsProcessorFactory;
+export declare function createDefaultCodeScanningProcessorFactory(executor: ProcessExecutor): CodeScanningProcessorFactory;
+export declare function createDefaultFactories(executor: ProcessExecutor, overrides?: Partial<SettingsProcessorFactories>): SettingsProcessorFactories;

package/dist/cli/settings-factories.js

@@ -0,0 +1,27 @@
+import { RulesetProcessor, RepoSettingsProcessor, LabelsProcessor, CodeScanningProcessor, GitHubRulesetStrategy, GitHubRepoSettingsStrategy, GitHubLabelsStrategy, GitHubCodeScanningStrategy, } from "../settings/index.js";
+import { GitHubRepoMetadataProvider } from "../repo/index.js";
+export function createDefaultRulesetProcessorFactory(executor) {
+    const cwd = process.cwd();
+    return () => new RulesetProcessor(new GitHubRulesetStrategy(executor, { cwd }));
+}
+export function createDefaultRepoSettingsProcessorFactory(executor) {
+    const cwd = process.cwd();
+    return () => new RepoSettingsProcessor(new GitHubRepoSettingsStrategy(executor, { cwd }), new GitHubRepoMetadataProvider(executor, { cwd }));
+}
+export function createDefaultLabelsProcessorFactory(executor) {
+    const cwd = process.cwd();
+    return () => new LabelsProcessor(new GitHubLabelsStrategy(executor, { cwd }));
+}
+export function createDefaultCodeScanningProcessorFactory(executor) {
+    const cwd = process.cwd();
+    return () => new CodeScanningProcessor(new GitHubCodeScanningStrategy(executor, { cwd }), new GitHubRepoMetadataProvider(executor, { cwd }));
+}
+export function createDefaultFactories(executor, overrides) {
+    return {
+        rulesets: overrides?.rulesets ?? createDefaultRulesetProcessorFactory(executor),
+        labels: overrides?.labels ?? createDefaultLabelsProcessorFactory(executor),
+        repo: overrides?.repo ?? createDefaultRepoSettingsProcessorFactory(executor),
+        codeScanning: overrides?.codeScanning ??
+            createDefaultCodeScanningProcessorFactory(executor),
+    };
+}

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

@@ -1,4 +1,4 @@
-import type { SettingsReport } from "../output/settings-report.js";
+import type { SettingsReport } from "../output/index.js";
 import { type RepoSettingsPlanEntry, type RulesetPlanEntry, type LabelsPlanEntry, type CodeScanningPlanEntry } from "../settings/index.js";
 /**
  * Result from processing a repository's settings and rulesets.

package/dist/cli/settings-report-builder.js

@@ -13,10 +13,8 @@ export function buildSettingsReport(results) {
             rulesets: [],
             labels: [],
         };
-        // Convert settings processor output
         if (result.settingsResult?.planOutput?.entries) {
             for (const entry of result.settingsResult.planOutput.entries) {
-                // Skip settings where both values are undefined (no actual change)
                 if (entry.oldValue === undefined && entry.newValue === undefined) {
                     continue;
                 }
@@ -27,11 +25,22 @@ export function buildSettingsReport(results) {
                     newValue: entry.newValue,
                 });
             }
+        }
+        if (result.codeScanningResult?.planOutput?.entries) {
+            for (const entry of result.codeScanningResult.planOutput.entries) {
+                repoChanges.settings.push({
+                    name: `codeScanning.${entry.property}`,
+                    action: entry.action,
+                    oldValue: entry.oldValue,
+                    newValue: entry.newValue ?? null,
+                });
+            }
+        }
+        if (repoChanges.settings.length > 0) {
             const counts = countActions(repoChanges.settings);
             totals.settings.create += counts.create;
             totals.settings.update += counts.update;
         }
-        // Convert ruleset processor output
         if (result.rulesetResult?.planOutput?.entries) {
             for (const entry of result.rulesetResult.planOutput.entries) {
                 if (!isActiveAction(entry))
@@ -48,7 +57,6 @@ export function buildSettingsReport(results) {
             totals.rulesets.update += counts.update;
             totals.rulesets.delete += counts.delete;
         }
-        // Convert labels processor output
         if (result.labelsResult?.planOutput?.entries) {
             for (const entry of result.labelsResult.planOutput.entries) {
                 if (!isActiveAction(entry))
@@ -66,25 +74,6 @@ export function buildSettingsReport(results) {
             totals.labels.update += counts.update;
             totals.labels.delete += counts.delete;
         }
-        // Convert code scanning processor output
-        if (result.codeScanningResult?.planOutput?.entries) {
-            let csCreates = 0;
-            let csUpdates = 0;
-            for (const entry of result.codeScanningResult.planOutput.entries) {
-                repoChanges.settings.push({
-                    name: `codeScanning.${entry.property}`,
-                    action: entry.action,
-                    oldValue: entry.oldValue,
-                    newValue: entry.newValue ?? null,
-                });
-                if (entry.action === "create")
-                    csCreates++;
-                if (entry.action === "update")
-                    csUpdates++;
-            }
-            totals.settings.create += csCreates;
-            totals.settings.update += csUpdates;
-        }
         if (result.error) {
             repoChanges.error = result.error;
         }

package/dist/cli/settings-runner.d.ts

@@ -0,0 +1,2 @@
+import type { ApplyRepoSettingsContext } from "./types.js";
+export declare function applyRepoSettings(ctx: ApplyRepoSettingsContext): Promise<void>;

package/dist/cli/settings-runner.js

@@ -0,0 +1,87 @@
+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;
+            }),
+        },
+    ];
+}
+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>;