@aspruyt/xfg 3.8.1 → 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/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.1",
-  "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": {