@aspruyt/xfg 3.8.0 → 3.8.2

package/README.md

@@ -76,7 +76,7 @@ settings:
       enforcement: active
       conditions:
         refName:
-          include: ["refs/heads/main"]
+          include: [refs/heads/main]
           exclude: []
       rules:
         - type: pull_request

package/dist/cli/program.js

@@ -56,9 +56,9 @@ const syncCommand = new Command("sync")
 });
 addSharedOptions(syncCommand);
 program.addCommand(syncCommand);
-// Settings command (ruleset management)
+// Settings command (repository settings and rulesets)
 const settingsCommand = new Command("settings")
-    .description("Manage GitHub Rulesets for repositories")
+    .description("Manage GitHub repository settings and rulesets")
     .action((opts) => {
     runSettings(opts).catch((error) => {
         console.error("Fatal error:", error);

package/dist/cli/settings-command.js

@@ -9,58 +9,42 @@ import { generateWorkspaceName } from "../shared/workspace-utils.js";
 import { buildErrorResult } from "../output/summary-utils.js";
 import { getManagedRulesets } from "../sync/manifest.js";
 import { formatSettingsReportCLI, writeSettingsReportSummary, } from "../output/settings-report.js";
-import { buildSettingsReport } from "./settings-report-builder.js";
+import { buildSettingsReport, } from "./settings-report-builder.js";
 import { defaultProcessorFactory, defaultRulesetProcessorFactory, defaultRepoSettingsProcessorFactory, } from "./types.js";
 /**
- * Run the settings command - manages GitHub Rulesets and repo settings.
+ * Collects processing results for the SettingsReport.
+ * Provides a centralized way to track results across rulesets and repo settings.
  */
-export async function runSettings(options, processorFactory = defaultRulesetProcessorFactory, repoProcessorFactory = defaultProcessorFactory, repoSettingsProcessorFactory = defaultRepoSettingsProcessorFactory) {
-    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 {
-        validateForSettings(rawConfig);
-    }
-    catch (error) {
-        console.error(error instanceof Error ? error.message : String(error));
-        process.exit(1);
-    }
-    const config = normalizeConfig(rawConfig);
-    const reposWithRulesets = config.repos.filter((r) => r.settings?.rulesets && Object.keys(r.settings.rulesets).length > 0);
-    const reposWithRepoSettings = config.repos.filter((r) => r.settings?.repo && Object.keys(r.settings.repo).length > 0);
-    if (reposWithRulesets.length === 0 && reposWithRepoSettings.length === 0) {
-        console.log("No settings configured. Add settings.rulesets or settings.repo to your config.");
-        return;
-    }
-    if (reposWithRulesets.length > 0) {
-        console.log(`Found ${reposWithRulesets.length} repositories with rulesets`);
-    }
-    if (reposWithRepoSettings.length > 0) {
-        console.log(`Found ${reposWithRepoSettings.length} repositories with repo settings`);
-    }
-    console.log("");
-    logger.setTotal(reposWithRulesets.length + reposWithRepoSettings.length);
-    const processor = processorFactory();
-    const repoProcessor = repoProcessorFactory();
-    const results = [];
-    const processingResults = [];
-    function getOrCreateResult(repoName) {
-        let result = processingResults.find((r) => r.repoName === repoName);
+class ResultsCollector {
+    results = [];
+    getOrCreate(repoName) {
+        let result = this.results.find((r) => r.repoName === repoName);
         if (!result) {
             result = { repoName };
-            processingResults.push(result);
+            this.results.push(result);
         }
         return result;
     }
-    for (let i = 0; i < reposWithRulesets.length; i++) {
-        const repoConfig = reposWithRulesets[i];
+    appendError(repoName, error) {
+        const existing = this.getOrCreate(repoName);
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        if (existing.error) {
+            existing.error += `; ${errorMsg}`;
+        }
+        else {
+            existing.error = errorMsg;
+        }
+    }
+    getAll() {
+        return this.results;
+    }
+}
+/**
+ * Process rulesets for all configured repositories.
+ */
+async function processRulesets(repos, config, options, processor, repoProcessor, results, collector) {
+    for (let i = 0; i < repos.length; i++) {
+        const repoConfig = repos[i];
         let repoInfo;
         try {
             repoInfo = parseGitUrl(repoConfig.git, {
@@ -70,14 +54,12 @@ export async function runSettings(options, processorFactory = defaultRulesetProc
         catch (error) {
             logger.error(i + 1, repoConfig.git, String(error));
             results.push(buildErrorResult(repoConfig.git, error));
-            getOrCreateResult(repoConfig.git).error =
-                error instanceof Error ? error.message : String(error);
+            collector.appendError(repoConfig.git, error);
             continue;
         }
         const repoName = getRepoDisplayName(repoInfo);
         if (!isGitHubRepo(repoInfo)) {
             logger.skip(i + 1, repoName, "GitHub Rulesets only supported for GitHub repos");
-            // Skipped repos don't appear in the report
             continue;
         }
         const managedRulesets = getManagedRulesets(null, config.id);
@@ -130,101 +112,133 @@ export async function runSettings(options, processorFactory = defaultRulesetProc
                 message: result.message,
                 rulesetPlanDetails: result.planOutput?.entries,
             });
-            // Collect result for SettingsReport
             if (!result.skipped) {
-                getOrCreateResult(repoName).rulesetResult = result;
+                collector.getOrCreate(repoName).rulesetResult = result;
             }
         }
         catch (error) {
             logger.error(i + 1, repoName, String(error));
             results.push(buildErrorResult(repoName, error));
-            const existingResult = getOrCreateResult(repoName);
-            const errorMsg = error instanceof Error ? error.message : String(error);
-            if (existingResult.error) {
-                existingResult.error += `; ${errorMsg}`;
-            }
-            else {
-                existingResult.error = errorMsg;
-            }
+            collector.appendError(repoName, error);
         }
     }
-    if (reposWithRepoSettings.length > 0) {
-        const repoSettingsProcessor = repoSettingsProcessorFactory();
-        console.log(`\nProcessing repo settings for ${reposWithRepoSettings.length} repositories\n`);
-        for (let i = 0; i < reposWithRepoSettings.length; i++) {
-            const repoConfig = reposWithRepoSettings[i];
-            let repoInfo;
-            try {
-                repoInfo = parseGitUrl(repoConfig.git, {
-                    githubHosts: config.githubHosts,
-                });
-            }
-            catch (error) {
-                console.error(`Failed to parse ${repoConfig.git}: ${error}`);
-                getOrCreateResult(repoConfig.git).error =
-                    error instanceof Error ? error.message : String(error);
-                continue;
-            }
-            const repoName = getRepoDisplayName(repoInfo);
-            try {
-                const result = await repoSettingsProcessor.process(repoConfig, repoInfo, {
-                    dryRun: options.dryRun,
-                });
-                if (result.planOutput && result.planOutput.lines.length > 0) {
-                    console.log(`\n  ${chalk.bold(repoName)}:`);
-                    console.log("  Repo Settings:");
-                    for (const line of result.planOutput.lines) {
-                        console.log(line);
-                    }
-                    if (result.warnings && result.warnings.length > 0) {
-                        for (const warning of result.warnings) {
-                            console.log(chalk.yellow(`  ⚠️  Warning: ${warning}`));
-                        }
-                    }
-                }
-                if (result.skipped) {
-                    // Silent skip
-                }
-                else if (result.success) {
-                    console.log(chalk.green(`  ✓ ${repoName}: ${result.message}`));
-                }
-                else {
-                    console.log(chalk.red(`  ✗ ${repoName}: ${result.message}`));
+}
+/**
+ * Process repo settings for all configured repositories.
+ */
+async function processRepoSettings(repos, config, options, processorFactory, results, collector) {
+    if (repos.length === 0) {
+        return;
+    }
+    const processor = processorFactory();
+    console.log(`\nProcessing repo settings for ${repos.length} repositories\n`);
+    for (let i = 0; i < repos.length; i++) {
+        const repoConfig = repos[i];
+        let repoInfo;
+        try {
+            repoInfo = parseGitUrl(repoConfig.git, {
+                githubHosts: config.githubHosts,
+            });
+        }
+        catch (error) {
+            console.error(`Failed to parse ${repoConfig.git}: ${error}`);
+            collector.appendError(repoConfig.git, error);
+            continue;
+        }
+        const repoName = getRepoDisplayName(repoInfo);
+        try {
+            const result = await processor.process(repoConfig, repoInfo, {
+                dryRun: options.dryRun,
+            });
+            if (result.planOutput && result.planOutput.lines.length > 0) {
+                console.log(`\n  ${chalk.bold(repoName)}:`);
+                console.log("  Repo Settings:");
+                for (const line of result.planOutput.lines) {
+                    console.log(line);
                 }
-                if (!result.skipped) {
-                    const existing = results.find((r) => r.repoName === repoName);
-                    if (existing) {
-                        existing.repoSettingsPlanDetails = result.planOutput?.entries;
-                    }
-                    else {
-                        results.push({
-                            repoName,
-                            status: result.success ? "succeeded" : "failed",
-                            message: result.message,
-                            repoSettingsPlanDetails: result.planOutput?.entries,
-                        });
+                if (result.warnings && result.warnings.length > 0) {
+                    for (const warning of result.warnings) {
+                        console.log(chalk.yellow(`  ⚠️  Warning: ${warning}`));
                     }
                 }
-                // Collect result for SettingsReport
-                if (!result.skipped) {
-                    getOrCreateResult(repoName).settingsResult = result;
-                }
             }
-            catch (error) {
-                console.error(`  ✗ ${repoName}: ${error}`);
-                const existingResult = getOrCreateResult(repoName);
-                const errorMsg = error instanceof Error ? error.message : String(error);
-                if (existingResult.error) {
-                    existingResult.error += `; ${errorMsg}`;
+            if (result.skipped) {
+                // Silent skip
+            }
+            else if (result.success) {
+                console.log(chalk.green(`  ✓ ${repoName}: ${result.message}`));
+            }
+            else {
+                console.log(chalk.red(`  ✗ ${repoName}: ${result.message}`));
+            }
+            if (!result.skipped) {
+                const existing = results.find((r) => r.repoName === repoName);
+                if (existing) {
+                    existing.repoSettingsPlanDetails = result.planOutput?.entries;
                 }
                 else {
-                    existingResult.error = errorMsg;
+                    results.push({
+                        repoName,
+                        status: result.success ? "succeeded" : "failed",
+                        message: result.message,
+                        repoSettingsPlanDetails: result.planOutput?.entries,
+                    });
                 }
             }
+            if (!result.skipped) {
+                collector.getOrCreate(repoName).settingsResult = result;
+            }
+        }
+        catch (error) {
+            console.error(`  ✗ ${repoName}: ${error}`);
+            collector.appendError(repoName, error);
         }
     }
+}
+/**
+ * Run the settings command - manages GitHub Rulesets and repo settings.
+ */
+export async function runSettings(options, processorFactory = defaultRulesetProcessorFactory, repoProcessorFactory = defaultProcessorFactory, repoSettingsProcessorFactory = defaultRepoSettingsProcessorFactory) {
+    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 {
+        validateForSettings(rawConfig);
+    }
+    catch (error) {
+        console.error(error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+    const config = normalizeConfig(rawConfig);
+    const reposWithRulesets = config.repos.filter((r) => r.settings?.rulesets && Object.keys(r.settings.rulesets).length > 0);
+    const reposWithRepoSettings = config.repos.filter((r) => r.settings?.repo && Object.keys(r.settings.repo).length > 0);
+    if (reposWithRulesets.length === 0 && reposWithRepoSettings.length === 0) {
+        console.log("No settings configured. Add settings.rulesets or settings.repo to your config.");
+        return;
+    }
+    if (reposWithRulesets.length > 0) {
+        console.log(`Found ${reposWithRulesets.length} repositories with rulesets`);
+    }
+    if (reposWithRepoSettings.length > 0) {
+        console.log(`Found ${reposWithRepoSettings.length} repositories with repo settings`);
+    }
+    console.log("");
+    logger.setTotal(reposWithRulesets.length + reposWithRepoSettings.length);
+    const processor = processorFactory();
+    const repoProcessor = repoProcessorFactory();
+    const results = [];
+    const collector = new ResultsCollector();
+    await processRulesets(reposWithRulesets, config, options, processor, repoProcessor, results, collector);
+    await processRepoSettings(reposWithRepoSettings, config, options, repoSettingsProcessorFactory, results, collector);
     console.log("");
-    const report = buildSettingsReport(processingResults);
+    const report = buildSettingsReport(collector.getAll());
     const lines = formatSettingsReportCLI(report);
     for (const line of lines) {
         console.log(line);

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

@@ -1,7 +1,11 @@
 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";
-interface ProcessorResults {
+/**
+ * Result from processing a repository's settings and rulesets.
+ * Used to collect results during settings command execution.
+ */
+export interface ProcessorResults {
     repoName: string;
     settingsResult?: {
         planOutput?: {
@@ -16,4 +20,3 @@ interface ProcessorResults {
     error?: string;
 }
 export declare function buildSettingsReport(results: ProcessorResults[]): SettingsReport;
-export {};

package/dist/sync/file-sync-strategy.d.ts

@@ -0,0 +1,12 @@
+import type { RepoConfig } from "../config/types.js";
+import type { RepoInfo } from "../shared/repo-detector.js";
+import type { IWorkStrategy, WorkResult, SessionContext, ProcessorOptions, IFileSyncOrchestrator } from "./types.js";
+/**
+ * Strategy that performs full file synchronization.
+ * Wraps FileSyncOrchestrator to fit the IWorkStrategy interface.
+ */
+export declare class FileSyncStrategy implements IWorkStrategy {
+    private readonly fileSyncOrchestrator;
+    constructor(fileSyncOrchestrator: IFileSyncOrchestrator);
+    execute(repoConfig: RepoConfig, repoInfo: RepoInfo, session: SessionContext, options: ProcessorOptions): Promise<WorkResult | null>;
+}

package/dist/sync/file-sync-strategy.js

@@ -0,0 +1,30 @@
+import { formatCommitMessage } from "./commit-message.js";
+/**
+ * Strategy that performs full file synchronization.
+ * Wraps FileSyncOrchestrator to fit the IWorkStrategy interface.
+ */
+export class FileSyncStrategy {
+    fileSyncOrchestrator;
+    constructor(fileSyncOrchestrator) {
+        this.fileSyncOrchestrator = fileSyncOrchestrator;
+    }
+    async execute(repoConfig, repoInfo, session, options) {
+        const { fileChanges, diffStats, changedFiles, hasChanges } = await this.fileSyncOrchestrator.sync(repoConfig, repoInfo, session, options);
+        if (!hasChanges) {
+            return null;
+        }
+        const fileChangeDetails = changedFiles
+            .filter((f) => f.action !== "skip")
+            .map((f) => ({
+            path: f.fileName,
+            action: f.action,
+        }));
+        return {
+            fileChanges,
+            changedFiles,
+            diffStats,
+            commitMessage: formatCommitMessage(changedFiles),
+            fileChangeDetails,
+        };
+    }
+}

package/dist/sync/index.d.ts

@@ -7,7 +7,10 @@ export { CommitPushManager } from "./commit-push-manager.js";
 export { formatCommitMessage } from "./commit-message.js";
 export { FileSyncOrchestrator } from "./file-sync-orchestrator.js";
 export { PRMergeHandler } from "./pr-merge-handler.js";
-export type { IFileWriter, FileWriteContext, FileWriterDeps, FileWriteAllResult, FileWriteResult, IManifestManager, OrphanProcessResult, OrphanDeleteOptions, OrphanDeleteDeps, IBranchManager, BranchSetupOptions, IAuthOptionsBuilder, AuthResult, IRepositorySession, SessionOptions, SessionContext, ICommitPushManager, CommitPushOptions, CommitPushResult, GitOpsFactory, IRepositoryProcessor, ProcessorOptions, ProcessorResult, FileChangeDetail, IFileSyncOrchestrator, FileSyncResult, IPRMergeHandler, PRHandlerOptions, } from "./types.js";
+export { FileSyncStrategy } from "./file-sync-strategy.js";
+export { ManifestStrategy, type ManifestUpdateParams, } from "./manifest-strategy.js";
+export { SyncWorkflow } from "./sync-workflow.js";
+export type { IFileWriter, FileWriteContext, FileWriterDeps, FileWriteAllResult, FileWriteResult, IManifestManager, OrphanProcessResult, OrphanDeleteOptions, OrphanDeleteDeps, IBranchManager, BranchSetupOptions, IAuthOptionsBuilder, AuthResult, IRepositorySession, SessionOptions, SessionContext, ICommitPushManager, CommitPushOptions, CommitPushResult, GitOpsFactory, IRepositoryProcessor, ProcessorOptions, ProcessorResult, FileChangeDetail, IFileSyncOrchestrator, FileSyncResult, IPRMergeHandler, PRHandlerOptions, WorkResult, IWorkStrategy, ISyncWorkflow, } from "./types.js";
 export { RepositoryProcessor } from "./repository-processor.js";
 export { createEmptyManifest, loadManifest, saveManifest, getManagedFiles, getManagedRulesets, updateManifest, updateManifestRulesets, MANIFEST_FILENAME, type XfgManifest, type XfgManifestConfigEntry, } from "./manifest.js";
 export { getFileStatus, formatStatusBadge, formatDiffLine, generateDiff, createDiffStats, incrementDiffStats, type FileStatus, type DiffStats, } from "./diff-utils.js";

package/dist/sync/index.js

@@ -7,6 +7,10 @@ export { CommitPushManager } from "./commit-push-manager.js";
 export { formatCommitMessage } from "./commit-message.js";
 export { FileSyncOrchestrator } from "./file-sync-orchestrator.js";
 export { PRMergeHandler } from "./pr-merge-handler.js";
+// Strategy pattern components
+export { FileSyncStrategy } from "./file-sync-strategy.js";
+export { ManifestStrategy, } from "./manifest-strategy.js";
+export { SyncWorkflow } from "./sync-workflow.js";
 // Repository processor
 export { RepositoryProcessor } from "./repository-processor.js";
 // Manifest handling

package/dist/sync/manifest-strategy.d.ts

@@ -0,0 +1,20 @@
+import type { RepoConfig } from "../config/types.js";
+import type { RepoInfo } from "../shared/repo-detector.js";
+import type { ILogger } from "../shared/logger.js";
+import type { IWorkStrategy, WorkResult, SessionContext, ProcessorOptions } from "./types.js";
+/**
+ * Parameters for manifest-only updates
+ */
+export interface ManifestUpdateParams {
+    rulesets: string[];
+}
+/**
+ * Strategy that only updates the manifest with ruleset tracking.
+ * Used by updateManifestOnly() for settings command ruleset sync.
+ */
+export declare class ManifestStrategy implements IWorkStrategy {
+    private readonly params;
+    private readonly log;
+    constructor(params: ManifestUpdateParams, log: ILogger);
+    execute(_repoConfig: RepoConfig, _repoInfo: RepoInfo, _session: SessionContext, options: ProcessorOptions): Promise<WorkResult | null>;
+}

package/dist/sync/manifest-strategy.js

@@ -0,0 +1,47 @@
+import { loadManifest, saveManifest, updateManifestRulesets, MANIFEST_FILENAME, } from "./manifest.js";
+/**
+ * Strategy that only updates the manifest with ruleset tracking.
+ * Used by updateManifestOnly() for settings command ruleset sync.
+ */
+export class ManifestStrategy {
+    params;
+    log;
+    constructor(params, log) {
+        this.params = params;
+        this.log = log;
+    }
+    async execute(_repoConfig, _repoInfo, _session, options) {
+        const { workDir, dryRun, configId } = options;
+        // Load and update manifest
+        const existingManifest = loadManifest(workDir);
+        const rulesetsWithDeleteOrphaned = new Map(this.params.rulesets.map((name) => [name, true]));
+        const { manifest: newManifest } = updateManifestRulesets(existingManifest, configId, rulesetsWithDeleteOrphaned);
+        // Check if changed
+        const existingConfigs = existingManifest?.configs ?? {};
+        if (JSON.stringify(existingConfigs) === JSON.stringify(newManifest.configs)) {
+            return null;
+        }
+        if (dryRun) {
+            this.log.info(`Would update ${MANIFEST_FILENAME} with rulesets`);
+        }
+        saveManifest(workDir, newManifest);
+        const fileChanges = new Map([
+            [
+                MANIFEST_FILENAME,
+                {
+                    fileName: MANIFEST_FILENAME,
+                    content: JSON.stringify(newManifest, null, 2) + "\n",
+                    action: "update",
+                },
+            ],
+        ]);
+        return {
+            fileChanges,
+            changedFiles: [
+                { fileName: MANIFEST_FILENAME, action: "update" },
+            ],
+            commitMessage: "chore: update manifest with ruleset tracking",
+            fileChangeDetails: [{ path: MANIFEST_FILENAME, action: "update" }],
+        };
+    }
+}

package/dist/sync/repository-processor.d.ts

@@ -1,18 +1,15 @@
-import { RepoConfig } from "../config/index.js";
-import { RepoInfo } from "../shared/repo-detector.js";
+import type { RepoConfig } from "../config/index.js";
+import type { RepoInfo } from "../shared/repo-detector.js";
 import { ILogger } from "../shared/logger.js";
-import { type IFileWriter, type IManifestManager, type IBranchManager, type IAuthOptionsBuilder, type IRepositorySession, type ICommitPushManager, type IFileSyncOrchestrator, type IPRMergeHandler, type IRepositoryProcessor, type GitOpsFactory, type ProcessorOptions, type ProcessorResult } from "./index.js";
+import { type IFileWriter, type IManifestManager, type IBranchManager, type IAuthOptionsBuilder, type IRepositorySession, type ICommitPushManager, type IFileSyncOrchestrator, type IPRMergeHandler, type ISyncWorkflow, type IRepositoryProcessor, type GitOpsFactory, type ProcessorOptions, type ProcessorResult } from "./index.js";
+/**
+ * Thin facade that delegates to SyncWorkflow with appropriate strategy.
+ * process() uses FileSyncStrategy, updateManifestOnly() uses ManifestStrategy.
+ */
 export declare class RepositoryProcessor implements IRepositoryProcessor {
-    private readonly gitOpsFactory;
-    private readonly log;
-    private readonly authOptionsBuilder;
-    private readonly repositorySession;
-    private readonly commitPushManager;
-    private readonly fileWriter;
-    private readonly manifestManager;
-    private readonly branchManager;
+    private readonly syncWorkflow;
     private readonly fileSyncOrchestrator;
-    private readonly prMergeHandler;
+    private readonly log;
     constructor(gitOpsFactory?: GitOpsFactory, log?: ILogger, components?: {
         fileWriter?: IFileWriter;
         manifestManager?: IManifestManager;
@@ -22,6 +19,7 @@ export declare class RepositoryProcessor implements IRepositoryProcessor {
         commitPushManager?: ICommitPushManager;
         fileSyncOrchestrator?: IFileSyncOrchestrator;
         prMergeHandler?: IPRMergeHandler;
+        syncWorkflow?: ISyncWorkflow;
     });
     process(repoConfig: RepoConfig, repoInfo: RepoInfo, options: ProcessorOptions): Promise<ProcessorResult>;
     updateManifestOnly(repoInfo: RepoInfo, repoConfig: RepoConfig, options: ProcessorOptions, manifestUpdate: {

package/dist/sync/repository-processor.js

@@ -1,298 +1,77 @@
-import { getRepoDisplayName } from "../shared/repo-detector.js";
 import { GitOps } from "../vcs/git-ops.js";
 import { AuthenticatedGitOps } from "../vcs/authenticated-git-ops.js";
 import { logger } from "../shared/logger.js";
 import { hasGitHubAppCredentials } from "../vcs/index.js";
-import { defaultExecutor } from "../shared/command-executor.js";
-import { loadManifest, saveManifest, updateManifestRulesets, MANIFEST_FILENAME, } from "./manifest.js";
 import { GitHubAppTokenManager } from "../vcs/github-app-token-manager.js";
-import { formatCommitMessage } from "./commit-message.js";
-import { FileWriter, ManifestManager, BranchManager, AuthOptionsBuilder, RepositorySession, CommitPushManager, FileSyncOrchestrator, PRMergeHandler, } from "./index.js";
-function mapToFileChangeDetails(changedFiles) {
-    return changedFiles
-        .filter((f) => f.action !== "skip")
-        .map((f) => ({
-        path: f.fileName,
-        action: f.action,
-    }));
-}
+import { FileWriter, ManifestManager, BranchManager, AuthOptionsBuilder, RepositorySession, CommitPushManager, FileSyncOrchestrator, PRMergeHandler, FileSyncStrategy, ManifestStrategy, SyncWorkflow, loadManifest, updateManifestRulesets, MANIFEST_FILENAME, } from "./index.js";
+import { getRepoDisplayName } from "../shared/repo-detector.js";
+/**
+ * Thin facade that delegates to SyncWorkflow with appropriate strategy.
+ * process() uses FileSyncStrategy, updateManifestOnly() uses ManifestStrategy.
+ */
 export class RepositoryProcessor {
-    gitOpsFactory;
-    log;
-    authOptionsBuilder;
-    repositorySession;
-    commitPushManager;
-    fileWriter;
-    manifestManager;
-    branchManager;
+    syncWorkflow;
     fileSyncOrchestrator;
-    prMergeHandler;
+    log;
     constructor(gitOpsFactory, log, components) {
         const factory = gitOpsFactory ??
             ((opts, auth) => new AuthenticatedGitOps(new GitOps(opts), auth));
         const logInstance = log ?? logger;
-        this.gitOpsFactory = factory;
         this.log = logInstance;
-        this.fileWriter = components?.fileWriter ?? new FileWriter();
-        this.manifestManager = components?.manifestManager ?? new ManifestManager();
-        this.branchManager = components?.branchManager ?? new BranchManager();
         // Initialize token manager for auth builder
         const tokenManager = hasGitHubAppCredentials()
             ? new GitHubAppTokenManager(process.env.XFG_GITHUB_APP_ID, process.env.XFG_GITHUB_APP_PRIVATE_KEY)
             : null;
-        this.authOptionsBuilder =
-            components?.authOptionsBuilder ??
-                new AuthOptionsBuilder(tokenManager, logInstance);
-        this.repositorySession =
-            components?.repositorySession ??
-                new RepositorySession(factory, logInstance);
-        this.commitPushManager =
-            components?.commitPushManager ?? new CommitPushManager(logInstance);
+        const fileWriter = components?.fileWriter ?? new FileWriter();
+        const manifestManager = components?.manifestManager ?? new ManifestManager();
+        const branchManager = components?.branchManager ?? new BranchManager();
+        const authOptionsBuilder = components?.authOptionsBuilder ??
+            new AuthOptionsBuilder(tokenManager, logInstance);
+        const repositorySession = components?.repositorySession ??
+            new RepositorySession(factory, logInstance);
+        const commitPushManager = components?.commitPushManager ?? new CommitPushManager(logInstance);
+        const prMergeHandler = components?.prMergeHandler ?? new PRMergeHandler(logInstance);
         this.fileSyncOrchestrator =
             components?.fileSyncOrchestrator ??
-                new FileSyncOrchestrator(this.fileWriter, this.manifestManager, logInstance);
-        this.prMergeHandler =
-            components?.prMergeHandler ?? new PRMergeHandler(logInstance);
+                new FileSyncOrchestrator(fileWriter, manifestManager, logInstance);
+        this.syncWorkflow =
+            components?.syncWorkflow ??
+                new SyncWorkflow(authOptionsBuilder, repositorySession, branchManager, commitPushManager, prMergeHandler, logInstance);
     }
     async process(repoConfig, repoInfo, options) {
-        const repoName = getRepoDisplayName(repoInfo);
-        const { branchName, workDir, dryRun, prTemplate } = options;
-        const retries = options.retries ?? 3;
-        const executor = options.executor ?? defaultExecutor;
-        // Resolve auth
-        const authResult = await this.authOptionsBuilder.resolve(repoInfo, repoName);
-        if (authResult.skipResult) {
-            return authResult.skipResult;
-        }
-        // Determine merge mode
-        const mergeMode = repoConfig.prOptions?.merge ?? "auto";
-        const isDirectMode = mergeMode === "direct";
-        if (isDirectMode && repoConfig.prOptions?.mergeStrategy) {
-            this.log.info(`Warning: mergeStrategy '${repoConfig.prOptions.mergeStrategy}' is ignored in direct mode`);
-        }
-        let session = null;
-        try {
-            // Setup workspace
-            session = await this.repositorySession.setup(repoInfo, {
-                workDir,
-                dryRun: dryRun ?? false,
-                retries,
-                authOptions: authResult.authOptions,
-            });
-            // Setup branch
-            await this.branchManager.setupBranch({
-                repoInfo,
-                branchName,
-                baseBranch: session.baseBranch,
-                workDir,
-                isDirectMode,
-                dryRun: dryRun ?? false,
-                retries,
-                token: authResult.token,
-                gitOps: session.gitOps,
-                log: this.log,
-                executor,
-            });
-            // Process files and manifest
-            const { fileChanges, diffStats, changedFiles, hasChanges } = await this.fileSyncOrchestrator.sync(repoConfig, repoInfo, session, options);
-            // Map file changes for reporting
-            const fileChangeDetails = mapToFileChangeDetails(changedFiles);
-            if (!hasChanges) {
-                return {
-                    success: true,
-                    repoName,
-                    message: "No changes detected",
-                    skipped: true,
-                    diffStats,
-                    fileChanges: fileChangeDetails,
-                };
-            }
-            // Commit and push
-            const commitMessage = formatCommitMessage(changedFiles);
-            const pushBranch = isDirectMode ? session.baseBranch : branchName;
-            const commitResult = await this.commitPushManager.commitAndPush({
-                repoInfo,
-                gitOps: session.gitOps,
-                workDir,
-                fileChanges,
-                commitMessage,
-                pushBranch,
-                isDirectMode,
-                dryRun: dryRun ?? false,
-                retries,
-                token: authResult.token,
-                executor,
-            }, repoName);
-            if (!commitResult.success && commitResult.errorResult) {
-                return commitResult.errorResult;
-            }
-            if (commitResult.skipped) {
-                return {
-                    success: true,
-                    repoName,
-                    message: "No changes detected after staging",
-                    skipped: true,
-                    diffStats,
-                    fileChanges: fileChangeDetails,
-                };
-            }
-            // Direct mode: no PR
-            if (isDirectMode) {
-                this.log.info(`Changes pushed directly to ${session.baseBranch}`);
-                return {
-                    success: true,
-                    repoName,
-                    message: `Pushed directly to ${session.baseBranch}`,
-                    diffStats,
-                    fileChanges: fileChangeDetails,
-                };
-            }
-            // Create and merge PR
-            return await this.prMergeHandler.createAndMerge(repoInfo, repoConfig, {
-                branchName,
-                baseBranch: session.baseBranch,
-                workDir,
-                dryRun: dryRun ?? false,
-                retries,
-                prTemplate,
-                token: authResult.token,
-                executor,
-            }, changedFiles, repoName, diffStats, fileChangeDetails);
-        }
-        finally {
-            try {
-                session?.cleanup();
-            }
-            catch {
-                // Ignore cleanup errors - best effort
-            }
-        }
+        const strategy = new FileSyncStrategy(this.fileSyncOrchestrator);
+        return this.syncWorkflow.execute(repoConfig, repoInfo, options, strategy);
     }
     async updateManifestOnly(repoInfo, repoConfig, options, manifestUpdate) {
         const repoName = getRepoDisplayName(repoInfo);
-        const { branchName, workDir, dryRun } = options;
-        const retries = options.retries ?? 3;
-        const executor = options.executor ?? defaultExecutor;
-        // Resolve auth
-        const authResult = await this.authOptionsBuilder.resolve(repoInfo, repoName);
-        if (authResult.skipResult) {
-            return authResult.skipResult;
-        }
-        const mergeMode = repoConfig.prOptions?.merge ?? "auto";
-        const isDirectMode = mergeMode === "direct";
-        let session = null;
-        try {
-            // Setup workspace
-            session = await this.repositorySession.setup(repoInfo, {
-                workDir,
-                dryRun: dryRun ?? false,
-                retries,
-                authOptions: authResult.authOptions,
-            });
-            // Load and update manifest
-            const existingManifest = loadManifest(workDir);
-            const rulesetsWithDeleteOrphaned = new Map(manifestUpdate.rulesets.map((name) => [name, true]));
-            const { manifest: newManifest } = updateManifestRulesets(existingManifest, options.configId, rulesetsWithDeleteOrphaned);
-            // Check if changed
-            const existingConfigs = existingManifest?.configs ?? {};
-            if (JSON.stringify(existingConfigs) === JSON.stringify(newManifest.configs)) {
-                return {
-                    success: true,
-                    repoName,
-                    message: "No manifest changes detected",
-                    skipped: true,
-                };
-            }
-            // Prepare manifest file change details for reporting
-            const manifestFileChange = [
-                { path: MANIFEST_FILENAME, action: "update" },
-            ];
-            if (dryRun) {
-                this.log.info(`Would update ${MANIFEST_FILENAME} with rulesets`);
-                return {
-                    success: true,
-                    repoName,
-                    message: "Would update manifest (dry-run)",
-                    fileChanges: manifestFileChange,
-                };
-            }
-            // Setup branch and commit
-            await this.branchManager.setupBranch({
-                repoInfo,
-                branchName,
-                baseBranch: session.baseBranch,
-                workDir,
-                isDirectMode,
-                dryRun: false,
-                retries,
-                token: authResult.token,
-                gitOps: session.gitOps,
-                log: this.log,
-                executor,
-            });
-            saveManifest(workDir, newManifest);
-            const fileChanges = new Map([
-                [
-                    MANIFEST_FILENAME,
-                    {
-                        fileName: MANIFEST_FILENAME,
-                        content: JSON.stringify(newManifest, null, 2) + "\n",
-                        action: "update",
-                    },
-                ],
-            ]);
-            const pushBranch = isDirectMode ? session.baseBranch : branchName;
-            const commitResult = await this.commitPushManager.commitAndPush({
-                repoInfo,
-                gitOps: session.gitOps,
-                workDir,
-                fileChanges,
-                commitMessage: "chore: update manifest with ruleset tracking",
-                pushBranch,
-                isDirectMode,
-                dryRun: false,
-                retries,
-                token: authResult.token,
-                executor,
-            }, repoName);
-            if (!commitResult.success && commitResult.errorResult) {
-                return commitResult.errorResult;
-            }
-            if (commitResult.skipped) {
-                return {
-                    success: true,
-                    repoName,
-                    message: "No changes detected after staging",
-                    skipped: true,
-                    fileChanges: manifestFileChange,
-                };
-            }
-            if (isDirectMode) {
-                return {
-                    success: true,
-                    repoName,
-                    message: `Manifest updated directly on ${session.baseBranch}`,
-                    fileChanges: manifestFileChange,
-                };
-            }
-            // Create and merge PR
-            return await this.prMergeHandler.createAndMerge(repoInfo, repoConfig, {
-                branchName,
-                baseBranch: session.baseBranch,
-                workDir,
-                dryRun: false,
-                retries,
-                token: authResult.token,
-                executor,
-            }, [{ fileName: MANIFEST_FILENAME, action: "update" }], repoName, undefined, manifestFileChange);
+        const { workDir, dryRun } = options;
+        // Pre-check manifest changes (preserves original early-return behavior)
+        const existingManifest = loadManifest(workDir);
+        const rulesetsWithDeleteOrphaned = new Map(manifestUpdate.rulesets.map((name) => [name, true]));
+        const { manifest: newManifest } = updateManifestRulesets(existingManifest, options.configId, rulesetsWithDeleteOrphaned);
+        const existingConfigs = existingManifest?.configs ?? {};
+        if (JSON.stringify(existingConfigs) === JSON.stringify(newManifest.configs)) {
+            return {
+                success: true,
+                repoName,
+                message: "No manifest changes detected",
+                skipped: true,
+            };
         }
-        finally {
-            try {
-                session?.cleanup();
-            }
-            catch {
-                // Ignore cleanup errors - best effort
-            }
+        const manifestFileChange = [
+            { path: MANIFEST_FILENAME, action: "update" },
+        ];
+        if (dryRun) {
+            this.log.info(`Would update ${MANIFEST_FILENAME} with rulesets`);
+            return {
+                success: true,
+                repoName,
+                message: "Would update manifest (dry-run)",
+                fileChanges: manifestFileChange,
+            };
         }
+        // Delegate to workflow for actual commit/push/PR
+        const strategy = new ManifestStrategy(manifestUpdate, this.log);
+        return this.syncWorkflow.execute(repoConfig, repoInfo, options, strategy);
     }
 }

package/dist/sync/sync-workflow.d.ts

@@ -0,0 +1,18 @@
+import type { RepoConfig } from "../config/types.js";
+import { RepoInfo } from "../shared/repo-detector.js";
+import type { ILogger } from "../shared/logger.js";
+import type { ISyncWorkflow, IWorkStrategy, IAuthOptionsBuilder, IRepositorySession, IBranchManager, ICommitPushManager, IPRMergeHandler, ProcessorOptions, ProcessorResult } from "./types.js";
+/**
+ * Orchestrates the common sync workflow steps.
+ * Used by RepositoryProcessor with different strategies for file sync vs manifest.
+ */
+export declare class SyncWorkflow implements ISyncWorkflow {
+    private readonly authOptionsBuilder;
+    private readonly repositorySession;
+    private readonly branchManager;
+    private readonly commitPushManager;
+    private readonly prMergeHandler;
+    private readonly log;
+    constructor(authOptionsBuilder: IAuthOptionsBuilder, repositorySession: IRepositorySession, branchManager: IBranchManager, commitPushManager: ICommitPushManager, prMergeHandler: IPRMergeHandler, log: ILogger);
+    execute(repoConfig: RepoConfig, repoInfo: RepoInfo, options: ProcessorOptions, workStrategy: IWorkStrategy): Promise<ProcessorResult>;
+}

package/dist/sync/sync-workflow.js

@@ -0,0 +1,134 @@
+import { getRepoDisplayName } from "../shared/repo-detector.js";
+import { defaultExecutor } from "../shared/command-executor.js";
+/**
+ * Orchestrates the common sync workflow steps.
+ * Used by RepositoryProcessor with different strategies for file sync vs manifest.
+ */
+export class SyncWorkflow {
+    authOptionsBuilder;
+    repositorySession;
+    branchManager;
+    commitPushManager;
+    prMergeHandler;
+    log;
+    constructor(authOptionsBuilder, repositorySession, branchManager, commitPushManager, prMergeHandler, log) {
+        this.authOptionsBuilder = authOptionsBuilder;
+        this.repositorySession = repositorySession;
+        this.branchManager = branchManager;
+        this.commitPushManager = commitPushManager;
+        this.prMergeHandler = prMergeHandler;
+        this.log = log;
+    }
+    async execute(repoConfig, repoInfo, options, workStrategy) {
+        const repoName = getRepoDisplayName(repoInfo);
+        const { branchName, workDir, dryRun } = options;
+        const retries = options.retries ?? 3;
+        const executor = options.executor ?? defaultExecutor;
+        // Step 1: Resolve auth
+        const authResult = await this.authOptionsBuilder.resolve(repoInfo, repoName);
+        if (authResult.skipResult) {
+            return authResult.skipResult;
+        }
+        // Step 2: Determine merge mode
+        const mergeMode = repoConfig.prOptions?.merge ?? "auto";
+        const isDirectMode = mergeMode === "direct";
+        // Warn if mergeStrategy is set but ignored in direct mode
+        if (isDirectMode && repoConfig.prOptions?.mergeStrategy) {
+            this.log.info(`Warning: mergeStrategy '${repoConfig.prOptions.mergeStrategy}' is ignored in direct mode`);
+        }
+        let session = null;
+        try {
+            // Step 3: Setup session
+            session = await this.repositorySession.setup(repoInfo, {
+                workDir,
+                dryRun: dryRun ?? false,
+                retries,
+                authOptions: authResult.authOptions,
+            });
+            // Step 4: Setup branch
+            await this.branchManager.setupBranch({
+                repoInfo,
+                branchName,
+                baseBranch: session.baseBranch,
+                workDir,
+                isDirectMode,
+                dryRun: dryRun ?? false,
+                retries,
+                token: authResult.token,
+                gitOps: session.gitOps,
+                log: this.log,
+                executor,
+            });
+            // Step 5: Execute work strategy
+            const workResult = await workStrategy.execute(repoConfig, repoInfo, session, options);
+            // Step 6: No changes - skip
+            if (!workResult) {
+                return {
+                    success: true,
+                    repoName,
+                    message: "No changes detected",
+                    skipped: true,
+                };
+            }
+            // Step 7: Commit and push
+            const pushBranch = isDirectMode ? session.baseBranch : branchName;
+            const commitResult = await this.commitPushManager.commitAndPush({
+                repoInfo,
+                gitOps: session.gitOps,
+                workDir,
+                fileChanges: workResult.fileChanges,
+                commitMessage: workResult.commitMessage,
+                pushBranch,
+                isDirectMode,
+                dryRun: dryRun ?? false,
+                retries,
+                token: authResult.token,
+                executor,
+            }, repoName);
+            // Step 8: Handle commit errors
+            if (!commitResult.success && commitResult.errorResult) {
+                return commitResult.errorResult;
+            }
+            if (commitResult.skipped) {
+                return {
+                    success: true,
+                    repoName,
+                    message: "No changes detected after staging",
+                    skipped: true,
+                    diffStats: workResult.diffStats,
+                    fileChanges: workResult.fileChangeDetails,
+                };
+            }
+            // Step 9: Direct mode - done
+            if (isDirectMode) {
+                this.log.info(`Changes pushed directly to ${session.baseBranch}`);
+                return {
+                    success: true,
+                    repoName,
+                    message: `Pushed directly to ${session.baseBranch}`,
+                    diffStats: workResult.diffStats,
+                    fileChanges: workResult.fileChangeDetails,
+                };
+            }
+            // Step 10: Create and merge PR
+            return await this.prMergeHandler.createAndMerge(repoInfo, repoConfig, {
+                branchName,
+                baseBranch: session.baseBranch,
+                workDir,
+                dryRun: dryRun ?? false,
+                retries,
+                prTemplate: options.prTemplate,
+                token: authResult.token,
+                executor,
+            }, workResult.changedFiles, repoName, workResult.diffStats, workResult.fileChangeDetails);
+        }
+        finally {
+            try {
+                session?.cleanup();
+            }
+            catch {
+                // Ignore cleanup errors - best effort
+            }
+        }
+    }
+}

package/dist/sync/types.d.ts

@@ -302,3 +302,38 @@ export interface IPRMergeHandler {
      */
     createAndMerge(repoInfo: RepoInfo, repoConfig: RepoConfig, options: PRHandlerOptions, changedFiles: FileAction[], repoName: string, diffStats?: DiffStats, fileChanges?: FileChangeDetail[]): Promise<ProcessorResult>;
 }
+/**
+ * Result of executing work within a sync workflow
+ */
+export interface WorkResult {
+    /** File changes to commit */
+    fileChanges: Map<string, FileWriteResult>;
+    /** Changed files for PR body */
+    changedFiles: FileAction[];
+    /** Diff statistics for reporting */
+    diffStats?: DiffStats;
+    /** Human-readable commit message */
+    commitMessage: string;
+    /** File change details for result reporting */
+    fileChangeDetails: FileChangeDetail[];
+}
+/**
+ * Strategy for executing work within the sync workflow.
+ * Implementations define what changes to make (files vs manifest).
+ */
+export interface IWorkStrategy {
+    /**
+     * Execute work and return changes to commit.
+     * Return null if no changes detected (workflow will skip).
+     */
+    execute(repoConfig: RepoConfig, repoInfo: RepoInfo, session: SessionContext, options: ProcessorOptions): Promise<WorkResult | null>;
+}
+/**
+ * Orchestrates the common sync workflow steps.
+ */
+export interface ISyncWorkflow {
+    /**
+     * Execute workflow: auth → session → branch → work → commit → PR
+     */
+    execute(repoConfig: RepoConfig, repoInfo: RepoInfo, options: ProcessorOptions, workStrategy: IWorkStrategy): Promise<ProcessorResult>;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@aspruyt/xfg",
-  "version": "3.8.0",
-  "description": "CLI tool for repository-as-code",
+  "version": "3.8.2",
+  "description": "CLI tool for repository-as-code: sync files and manage settings across GitHub, Azure DevOps, and GitLab",
   "type": "module",
   "main": "dist/index.js",
   "bin": {