@aspruyt/xfg 4.0.2 → 4.0.4

package/dist/shared/shell-utils.d.ts

@@ -2,8 +2,5 @@ export declare function escapeRegExp(str: string): string;
 /**
  * Escapes a string for safe use as a shell argument.
  * Uses single quotes and escapes any single quotes within the string.
- *
- * @param arg - The string to escape
- * @returns The escaped string wrapped in single quotes
  */
 export declare function escapeShellArg(arg: string): string;

package/dist/shared/shell-utils.js

@@ -1,17 +1,15 @@
+import { ValidationError } from "./errors.js";
 export function escapeRegExp(str) {
     return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 /**
  * Escapes a string for safe use as a shell argument.
  * Uses single quotes and escapes any single quotes within the string.
- *
- * @param arg - The string to escape
- * @returns The escaped string wrapped in single quotes
  */
 export function escapeShellArg(arg) {
     // Defense-in-depth: reject null bytes even if upstream validation should catch them
     if (arg.includes("\0")) {
-        throw new Error("Shell argument contains null byte");
+        throw new ValidationError("Shell argument contains null byte");
     }
     // Use single quotes and escape any single quotes within
     // 'string' -> quote ends, escaped quote, quote starts again

package/dist/shared/type-guards.d.ts

@@ -1,10 +1,5 @@
-/**
- * Check if a value is a plain object (not array, null, or other types).
- */
+import type { DebugLog } from "./logger.js";
 export declare function isPlainObject(val: unknown): val is Record<string, unknown>;
-/**
- * Extract an error message from an unknown thrown value.
- */
 export declare function toErrorMessage(error: unknown): string;
 /**
  * Run a cleanup action, swallowing errors with a debug log.
@@ -12,6 +7,4 @@ export declare function toErrorMessage(error: unknown): string;
  * If the function returns a Promise, the returned Promise resolves
  * after the cleanup completes (or fails silently).
  */
-export declare function safeCleanup(fn: () => void | Promise<void>, label: string, log: {
-    debug(msg: string): void;
-}): Promise<void>;
+export declare function safeCleanup(fn: () => void | Promise<void>, label: string, log: DebugLog): Promise<void>;

package/dist/shared/type-guards.js

@@ -1,12 +1,6 @@
-/**
- * Check if a value is a plain object (not array, null, or other types).
- */
 export function isPlainObject(val) {
     return typeof val === "object" && val !== null && !Array.isArray(val);
 }
-/**
- * Extract an error message from an unknown thrown value.
- */
 export function toErrorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }

package/dist/shared/xfg-template.d.ts

@@ -4,7 +4,7 @@
  * Use $${xfg:variable} to escape and output literal ${xfg:variable}.
  */
 import type { RepoInfo } from "./repo-detector.js";
-import type { ContentValue } from "../config/index.js";
+type TemplateContent = Record<string, unknown> | string | string[];
 export interface XfgTemplateContext {
     /** Repository information from URL parsing */
     repoInfo: RepoInfo;
@@ -40,5 +40,5 @@ interface XfgInterpolationOptions {
  * @param options - Interpolation options (default: strict mode)
  * @returns Content with interpolated values
  */
-export declare function interpolateXfgContent(content: ContentValue, ctx: XfgTemplateContext, options?: XfgInterpolationOptions): ContentValue;
+export declare function interpolateXfgContent(content: TemplateContent, ctx: XfgTemplateContext, options?: XfgInterpolationOptions): TemplateContent;
 export {};

package/dist/shared/xfg-template.js

@@ -4,6 +4,7 @@
  * Use $${xfg:variable} to escape and output literal ${xfg:variable}.
  */
 import { interpolateString, interpolateValue, } from "./interpolation-engine.js";
+import { ValidationError } from "./errors.js";
 const DEFAULT_OPTIONS = {
     strict: true,
 };
@@ -73,7 +74,7 @@ function buildXfgConfig(ctx, options) {
         }
         // Unknown variable
         if (options.strict) {
-            throw new Error(`Unknown xfg template variable: ${varName}`);
+            throw new ValidationError(`Unknown xfg template variable: ${varName}`);
         }
         // Non-strict mode - leave placeholder as-is
         return match;

package/dist/sync/auth-options-builder.d.ts

@@ -5,7 +5,8 @@ import type { ILogger } from "../shared/logger.js";
 export declare class AuthOptionsBuilder implements IAuthOptionsBuilder {
     private readonly tokenManager;
     private readonly log?;
-    constructor(tokenManager: GitHubAppTokenManager | null, log?: ILogger | undefined);
-    resolve(repoInfo: RepoInfo, repoName: string, preResolvedToken?: string): Promise<AuthResult>;
+    private readonly envToken?;
+    constructor(tokenManager: GitHubAppTokenManager | null, log?: ILogger | undefined, envToken?: string | undefined);
+    resolve(repoInfo: RepoInfo, repoName: string, token?: string): Promise<AuthResult>;
     private buildAuthOptions;
 }

package/dist/sync/auth-options-builder.js

@@ -3,20 +3,24 @@ import { resolveGitHubToken } from "../shared/gh-api-utils.js";
 export class AuthOptionsBuilder {
     tokenManager;
     log;
-    constructor(tokenManager, log) {
+    envToken;
+    constructor(tokenManager, log, envToken) {
         this.tokenManager = tokenManager;
         this.log = log;
+        this.envToken = envToken;
     }
-    async resolve(repoInfo, repoName, preResolvedToken) {
+    async resolve(repoInfo, repoName, token) {
         if (!isGitHubRepo(repoInfo)) {
             return { ok: true, token: undefined, authOptions: undefined };
         }
-        if (preResolvedToken !== undefined) {
-            const authOptions = this.buildAuthOptions(repoInfo, preResolvedToken);
-            return { ok: true, token: preResolvedToken, authOptions };
+        // If caller already resolved a token, use it directly
+        if (token !== undefined) {
+            const authOptions = this.buildAuthOptions(repoInfo, token);
+            return { ok: true, token, authOptions };
         }
-        const { token, skipped } = await resolveGitHubToken(repoInfo, this.tokenManager, repoName, this.log, process.env.GH_TOKEN);
-        if (skipped) {
+        // Otherwise resolve via token manager / env fallback
+        const resolved = await resolveGitHubToken(repoInfo, this.tokenManager, repoName, this.log, this.envToken);
+        if (resolved.skipped) {
             return {
                 ok: false,
                 skipResult: {
@@ -27,10 +31,10 @@ export class AuthOptionsBuilder {
                 },
             };
         }
-        const authOptions = token
-            ? this.buildAuthOptions(repoInfo, token)
+        const authOptions = resolved.token
+            ? this.buildAuthOptions(repoInfo, resolved.token)
             : undefined;
-        return { ok: true, token, authOptions };
+        return { ok: true, token: resolved.token, authOptions };
     }
     buildAuthOptions(repoInfo, token) {
         return {

package/dist/sync/branch-manager.d.ts

@@ -1,12 +1,17 @@
-import type { ILogger } from "../shared/logger.js";
+import type { IPRStrategy } from "../vcs/types.js";
+import type { RepoInfo } from "../shared/repo-detector.js";
+import type { ICommandExecutor } from "../shared/command-executor.js";
 import type { IBranchManager, BranchSetupOptions } from "./types.js";
-/**
- * Handles branch creation and existing PR cleanup.
- * Receives stable dependencies (logger) via constructor;
- * per-call data (repo, branch, executor) via setupBranch options.
- */
+type SyncLog = {
+    debug(msg: string): void;
+    info(msg: string): void;
+    warn(msg: string): void;
+};
+type PRStrategyFactory = (repoInfo: RepoInfo, executor: ICommandExecutor, log?: SyncLog) => IPRStrategy;
 export declare class BranchManager implements IBranchManager {
     private readonly log;
-    constructor(log: ILogger);
+    private readonly prStrategyFactory;
+    constructor(log: SyncLog, prStrategyFactory?: PRStrategyFactory);
     setupBranch(options: BranchSetupOptions): Promise<void>;
 }
+export {};

package/dist/sync/branch-manager.js

@@ -1,13 +1,10 @@
 import { getPRStrategy } from "../vcs/index.js";
-/**
- * Handles branch creation and existing PR cleanup.
- * Receives stable dependencies (logger) via constructor;
- * per-call data (repo, branch, executor) via setupBranch options.
- */
 export class BranchManager {
     log;
-    constructor(log) {
+    prStrategyFactory;
+    constructor(log, prStrategyFactory = getPRStrategy) {
         this.log = log;
+        this.prStrategyFactory = prStrategyFactory;
     }
     async setupBranch(options) {
         const { repoInfo, branchName, baseBranch, workDir, isDirectMode, dryRun, retries, token, gitOps, executor, } = options;
@@ -17,7 +14,7 @@ export class BranchManager {
         }
         if (!dryRun) {
             this.log.debug("Checking for existing PR...");
-            const strategy = getPRStrategy(repoInfo, executor, this.log);
+            const strategy = this.prStrategyFactory(repoInfo, executor, this.log);
             const closed = await strategy.closeExistingPR({
                 repoInfo,
                 branchName,

package/dist/sync/commit-message.d.ts

@@ -1,4 +1,4 @@
-import type { FileAction } from "../vcs/pr-creator.js";
+import type { FileAction } from "../vcs/types.js";
 /**
  * Format a commit message based on the files being changed.
  *

package/dist/sync/commit-push-manager.d.ts

@@ -1,8 +1,14 @@
-import { ILogger } from "../shared/logger.js";
+import type { ICommitStrategy } from "../vcs/types.js";
+import type { RepoInfo } from "../shared/repo-detector.js";
+import type { ICommandExecutor } from "../shared/command-executor.js";
 import type { CommitPushOptions, CommitPushResult, ICommitPushManager } from "./types.js";
+import type { DebugInfoLog } from "../shared/logger.js";
+type CommitStrategyFactory = (repoInfo: RepoInfo, executor: ICommandExecutor, hasAppCredentials?: boolean) => ICommitStrategy;
 export declare class CommitPushManager implements ICommitPushManager {
     private readonly log;
-    constructor(log: ILogger);
+    private readonly commitStrategyFactory;
+    constructor(log: DebugInfoLog, commitStrategyFactory?: CommitStrategyFactory);
     commitAndPush(options: CommitPushOptions): Promise<CommitPushResult>;
     private handleCommitError;
 }
+export {};

package/dist/sync/commit-push-manager.js

@@ -3,8 +3,10 @@ import { getRepoDisplayName } from "../shared/repo-detector.js";
 import { toErrorMessage } from "../shared/type-guards.js";
 export class CommitPushManager {
     log;
-    constructor(log) {
+    commitStrategyFactory;
+    constructor(log, commitStrategyFactory = getCommitStrategy) {
         this.log = log;
+        this.commitStrategyFactory = commitStrategyFactory;
     }
     async commitAndPush(options) {
         const { repoInfo, gitOps, workDir, fileChanges, commitMessage, pushBranch, isDirectMode, dryRun, retries, token, executor, } = options;
@@ -17,14 +19,13 @@ export class CommitPushManager {
         const changes = Array.from(fileChanges.entries())
             .filter(([, info]) => info.action !== "skip")
             .map(([path, info]) => ({ path, content: info.content }));
-        // Stage changes using injected executor (existing pattern in codebase)
         this.log.info("Staging changes...");
-        await executor.exec("git add -A", workDir);
+        await gitOps.stageAll();
         if (!(await gitOps.hasStagedChanges())) {
-            this.log.info("No staged changes after git add -A, skipping commit");
+            this.log.info("No staged changes, skipping commit");
             return { success: true, skipped: true };
         }
-        const commitStrategy = getCommitStrategy(repoInfo, executor);
+        const commitStrategy = this.commitStrategyFactory(repoInfo, executor, options.hasAppCredentials);
         this.log.debug("Committing and pushing changes...");
         try {
             const result = await commitStrategy.commit({

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

@@ -20,39 +20,35 @@ export class FileSyncOrchestrator {
             dryRun,
             noDelete,
             configId,
-            isGraphQLCommitMode: options.isGraphQLCommitMode,
+            hasAppCredentials: options.hasAppCredentials,
         }, { gitOps: session.gitOps, log: this.log });
         const existingManifest = loadManifest(workDir, this.log);
         const filesWithDeleteOrphaned = new Map(repoConfig.files.map((f) => [f.fileName, f.deleteOrphaned]));
         const { manifest: newManifest, filesToDelete } = this.manifestManager.processOrphans(workDir, configId, filesWithDeleteOrphaned);
         await this.manifestManager.deleteOrphans(filesToDelete, { dryRun: dryRun, noDelete: noDelete }, { gitOps: session.gitOps, log: this.log, fileChanges });
-        // Update diff stats for deletions in dry-run
-        if (dryRun && filesToDelete.length > 0 && !noDelete) {
-            for (const fileName of filesToDelete) {
-                if (session.gitOps.fileExists(fileName)) {
-                    incrementDiffStats(diffStats, "DELETED");
-                }
-            }
-        }
-        // Save manifest
+        // Save manifest (may add to fileChanges)
         this.manifestManager.saveUpdatedManifest(workDir, newManifest, existingManifest, dryRun, fileChanges);
+        // Count stats for entries added after writeFiles (orphan deletes + manifest).
+        // Invariant: writerFiles and post-write entries are disjoint — orphan deletes
+        // only target files NOT in the current config (see updateManifest), and
+        // the manifest file is never a config-managed file.
+        const writerFiles = new Set(repoConfig.files.map((f) => f.fileName));
+        for (const [name, info] of fileChanges) {
+            if (writerFiles.has(name))
+                continue;
+            if (info.action === "create")
+                incrementDiffStats(diffStats, "NEW");
+            else if (info.action === "update")
+                incrementDiffStats(diffStats, "MODIFIED");
+            else if (info.action === "delete")
+                incrementDiffStats(diffStats, "DELETED");
+        }
         // Show diff summary in dry-run
         if (dryRun) {
             this.log.diffSummary(diffStats.newCount, diffStats.modifiedCount, diffStats.unchangedCount, diffStats.deletedCount);
         }
         // Build changed files list
         const changedFiles = Array.from(fileChanges.entries()).map(([fileName, info]) => ({ fileName, action: info.action }));
-        // Calculate diff stats for non-dry-run
-        if (!dryRun) {
-            for (const [, info] of fileChanges) {
-                if (info.action === "create")
-                    incrementDiffStats(diffStats, "NEW");
-                else if (info.action === "update")
-                    incrementDiffStats(diffStats, "MODIFIED");
-                else if (info.action === "delete")
-                    incrementDiffStats(diffStats, "DELETED");
-            }
-        }
         const hasChanges = changedFiles.some((f) => f.action !== "skip");
         return { fileChanges, diffStats, changedFiles, hasChanges };
     }

package/dist/sync/file-writer.js

@@ -62,7 +62,6 @@ export class FileWriter {
             });
             // Determine action type (create vs update) BEFORE writing
             const action = fileExistsLocal ? "update" : "create";
-            // Check if file would change
             const existingContent = gitOps.getFileContent(file.fileName);
             const changed = gitOps.wouldChange(file.fileName, fileContent);
             if (changed) {
@@ -73,14 +72,13 @@ export class FileWriter {
                 });
             }
             if (dryRun) {
-                // In dry-run, show diff but don't write
                 const status = getFileStatus(existingContent !== null, changed);
                 incrementDiffStats(diffStats, status);
                 const diffLines = generateDiff(existingContent, fileContent, file.fileName);
                 log.fileDiff(file.fileName, status, diffLines);
             }
-            else {
-                // Write the file
+            else if (changed) {
+                incrementDiffStats(diffStats, action === "create" ? "NEW" : "MODIFIED");
                 gitOps.writeFile(file.fileName, fileContent);
             }
         }
@@ -90,7 +88,7 @@ export class FileWriter {
                 continue;
             }
             if (shouldBeExecutable(file)) {
-                if (tracked?.action === "create" && ctx.isGraphQLCommitMode) {
+                if (tracked?.action === "create" && ctx.hasAppCredentials) {
                     log.warn(`${file.fileName}: GitHub App commits cannot set executable mode on new files. ` +
                         `The file will be created as non-executable (100644). ` +
                         `See: https://anthony-spruyt.github.io/xfg/examples/executable-files/`);

package/dist/sync/index.d.ts

@@ -1,3 +1,3 @@
 export type { DiffStats } from "./diff-utils.js";
-export type { GitOpsFactory, IAuthOptionsBuilder, IBranchManager, ICommitPushManager, IFileSyncOrchestrator, IPRMergeHandler, IRepositoryProcessor, IRepositorySession, ISyncWorkflow, IWorkStrategy, ProcessorResult, SessionContext, WorkResult, } from "./types.js";
+export type { GitOpsFactory, IAuthOptionsBuilder, IBranchManager, ICommitPushManager, IFileSyncOrchestrator, IPRMergeHandler, IRepositoryProcessor, IRepositorySession, IWorkStrategy, ProcessorResult, SessionContext, WorkResult, } from "./types.js";
 export { RepositoryProcessor } from "./repository-processor.js";

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

@@ -7,6 +7,7 @@ export declare class ManifestManager implements IManifestManager {
     private readonly log?;
     constructor(log?: {
         debug(msg: string): void;
+        warn(msg: string): void;
     } | undefined);
     processOrphans(workDir: string, configId: string, filesWithDeleteOrphaned: Map<string, boolean | undefined>): OrphanProcessResult;
     deleteOrphans(filesToDelete: string[], options: OrphanDeleteOptions, deps: OrphanDeleteDeps): Promise<void>;

package/dist/sync/manifest.d.ts

@@ -1,3 +1,4 @@
+import type { DebugWarnLog } from "../shared/logger.js";
 export declare const MANIFEST_FILENAME = ".xfg.json";
 export interface XfgManifestConfigEntry {
     files?: string[];
@@ -11,16 +12,12 @@ export declare function createEmptyManifest(): XfgManifest;
  * Loads and migrates manifest from workDir. V1 returns null (no config-ID namespace);
  * V2/V3 are auto-migrated to V4.
  */
-export declare function loadManifest(workDir: string, log?: {
-    debug(msg: string): void;
-}): XfgManifest | null;
+export declare function loadManifest(workDir: string, log?: DebugWarnLog): XfgManifest | null;
 /**
  * Parses manifest content from a string (e.g., fetched from a remote API).
- * Handles V2→V3 migration, returns null for V1/unknown/invalid formats.
+ * Handles V2/V3 → V4 migration, returns null for V1/unknown/invalid formats.
  */
-export declare function parseManifestContent(content: string, log?: {
-    debug(msg: string): void;
-}): XfgManifest | null;
+export declare function parseManifestContent(content: string, log?: DebugWarnLog): XfgManifest | null;
 export declare function saveManifest(workDir: string, manifest: XfgManifest): void;
 export declare function getManagedFiles(manifest: XfgManifest | null, configId: string): string[];
 /**

package/dist/sync/manifest.js

@@ -1,32 +1,28 @@
 import { readFileSync, writeFileSync, existsSync } from "node:fs";
 import { join } from "node:path";
+import { toErrorMessage, isPlainObject } from "../shared/type-guards.js";
+import { SyncError } from "../shared/errors.js";
 export const MANIFEST_FILENAME = ".xfg.json";
+function hasVersion(manifest, version) {
+    return (isPlainObject(manifest) &&
+        manifest.version === version);
+}
 function isV1Manifest(manifest) {
-    return (typeof manifest === "object" &&
-        manifest !== null &&
-        manifest.version === 1 &&
+    return (hasVersion(manifest, 1) &&
         Array.isArray(manifest.managedFiles));
 }
+function hasConfigs(manifest) {
+    return (isPlainObject(manifest) &&
+        isPlainObject(manifest.configs));
+}
 function isV2Manifest(manifest) {
-    return (typeof manifest === "object" &&
-        manifest !== null &&
-        manifest.version === 2 &&
-        typeof manifest.configs === "object" &&
-        manifest.configs !== null);
+    return hasVersion(manifest, 2) && hasConfigs(manifest);
 }
 function isV3Manifest(manifest) {
-    return (typeof manifest === "object" &&
-        manifest !== null &&
-        manifest.version === 3 &&
-        typeof manifest.configs === "object" &&
-        manifest.configs !== null);
+    return hasVersion(manifest, 3) && hasConfigs(manifest);
 }
 function isV4Manifest(manifest) {
-    return (typeof manifest === "object" &&
-        manifest !== null &&
-        manifest.version === 4 &&
-        typeof manifest.configs === "object" &&
-        manifest.configs !== null);
+    return hasVersion(manifest, 4) && hasConfigs(manifest);
 }
 /**
  * Migrates a V2 manifest to V3 format.
@@ -60,6 +56,19 @@ function migrateV3ToV4(v3) {
     }
     return { version: 4, configs: v4Configs };
 }
+/**
+ * Migrates a parsed manifest to V4 if recognized (V2/V3/V4).
+ * Returns null for unrecognized formats.
+ */
+function migrateToV4(parsed) {
+    if (isV4Manifest(parsed))
+        return parsed;
+    if (isV3Manifest(parsed))
+        return migrateV3ToV4(parsed);
+    if (isV2Manifest(parsed))
+        return migrateV3ToV4(migrateV2ToV3(parsed));
+    return null;
+}
 export function createEmptyManifest() {
     return {
         version: 4,
@@ -78,57 +87,45 @@ export function loadManifest(workDir, log) {
     try {
         const content = readFileSync(manifestPath, "utf-8");
         const parsed = JSON.parse(content);
-        // V4 manifest - return as-is
-        if (isV4Manifest(parsed)) {
-            return parsed;
-        }
-        // V3 manifest - migrate to V4
-        if (isV3Manifest(parsed)) {
-            return migrateV3ToV4(parsed);
-        }
-        // V2 manifest - migrate to V3, then to V4
-        if (isV2Manifest(parsed)) {
-            return migrateV3ToV4(migrateV2ToV3(parsed));
-        }
+        const migrated = migrateToV4(parsed);
+        if (migrated)
+            return migrated;
         // V1 manifest - treat as no manifest (will be overwritten with v4)
         if (isV1Manifest(parsed)) {
             return null;
         }
-        // Unknown format - treat as no manifest
+        // Unknown format
+        log?.warn(`Unrecognized manifest format in ${manifestPath}, ignoring`);
         return null;
     }
     catch (error) {
-        log?.debug(`Failed to load manifest from ${manifestPath}: ${error}`);
+        log?.warn(`Failed to parse manifest ${manifestPath}: ${toErrorMessage(error)}`);
         return null;
     }
 }
 /**
  * Parses manifest content from a string (e.g., fetched from a remote API).
- * Handles V2→V3 migration, returns null for V1/unknown/invalid formats.
+ * Handles V2/V3 → V4 migration, returns null for V1/unknown/invalid formats.
  */
 export function parseManifestContent(content, log) {
     try {
         const parsed = JSON.parse(content);
-        if (isV4Manifest(parsed)) {
-            return parsed;
-        }
-        if (isV3Manifest(parsed)) {
-            return migrateV3ToV4(parsed);
-        }
-        if (isV2Manifest(parsed)) {
-            return migrateV3ToV4(migrateV2ToV3(parsed));
-        }
-        return null;
+        return migrateToV4(parsed);
     }
     catch (error) {
-        log?.debug(`Failed to parse manifest content: ${error}`);
+        log?.warn(`Failed to parse manifest content: ${toErrorMessage(error)}`);
         return null;
     }
 }
 export function saveManifest(workDir, manifest) {
     const manifestPath = join(workDir, MANIFEST_FILENAME);
     const content = JSON.stringify(manifest, null, 2) + "\n";
-    writeFileSync(manifestPath, content, "utf-8");
+    try {
+        writeFileSync(manifestPath, content, "utf-8");
+    }
+    catch (error) {
+        throw new SyncError(`Failed to save manifest ${manifestPath}: ${toErrorMessage(error)}`);
+    }
 }
 export function getManagedFiles(manifest, configId) {
     if (!manifest) {

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

@@ -1,6 +1,7 @@
 import type { RepoConfig } from "../config/index.js";
 import type { RepoInfo } from "../shared/repo-detector.js";
-import { ILogger } from "../shared/logger.js";
+import type { ILogger } from "../shared/logger.js";
+import type { GitHubAppTokenManager } from "../vcs/github-app-token-manager.js";
 import type { IFileWriter, IManifestManager, IBranchManager, IAuthOptionsBuilder, IRepositorySession, ICommitPushManager, IFileSyncOrchestrator, IPRMergeHandler, ISyncWorkflow, IRepositoryProcessor, GitOpsFactory, ProcessorOptions, ProcessorResult } from "./types.js";
 /**
  * Thin facade that delegates to SyncWorkflow with FileSyncStrategy.
@@ -8,7 +9,7 @@ import type { IFileWriter, IManifestManager, IBranchManager, IAuthOptionsBuilder
 export declare class RepositoryProcessor implements IRepositoryProcessor {
     private readonly syncWorkflow;
     private readonly fileSyncOrchestrator;
-    constructor(gitOpsFactory?: GitOpsFactory, log?: ILogger, components?: {
+    constructor(gitOpsFactory: GitOpsFactory | undefined, log: ILogger, components?: {
         fileWriter?: IFileWriter;
         manifestManager?: IManifestManager;
         branchManager?: IBranchManager;
@@ -18,6 +19,8 @@ export declare class RepositoryProcessor implements IRepositoryProcessor {
         fileSyncOrchestrator?: IFileSyncOrchestrator;
         prMergeHandler?: IPRMergeHandler;
         syncWorkflow?: ISyncWorkflow;
+        tokenManager?: GitHubAppTokenManager | null;
+        envToken?: string;
     });
     process(repoConfig: RepoConfig, repoInfo: RepoInfo, options: ProcessorOptions): Promise<ProcessorResult>;
 }

package/dist/sync/repository-processor.js

@@ -1,8 +1,5 @@
 import { GitOps } from "../vcs/git-ops.js";
 import { AuthenticatedGitOps } from "../vcs/authenticated-git-ops.js";
-import { defaultExecutor } from "../shared/command-executor.js";
-import { logger } from "../shared/logger.js";
-import { createTokenManager } from "../vcs/index.js";
 import { FileWriter } from "./file-writer.js";
 import { ManifestManager } from "./manifest-manager.js";
 import { BranchManager } from "./branch-manager.js";
@@ -20,29 +17,26 @@ export class RepositoryProcessor {
     syncWorkflow;
     fileSyncOrchestrator;
     constructor(gitOpsFactory, log, components) {
-        const logInstance = log ?? logger;
         const factory = gitOpsFactory ??
             ((opts, auth, retries) => {
-                const gitOps = new GitOps({ ...opts, log: logInstance });
-                return new AuthenticatedGitOps(gitOps, opts.executor ?? defaultExecutor, opts.workDir, retries ?? 3, auth, logInstance);
+                const gitOps = new GitOps({ ...opts, log: log });
+                return new AuthenticatedGitOps(gitOps, opts.executor, opts.workDir, retries ?? 3, auth, log);
             });
-        // Initialize token manager for auth builder
-        const tokenManager = createTokenManager();
+        const tokenManager = components?.tokenManager ?? null;
         const fileWriter = components?.fileWriter ?? new FileWriter();
-        const manifestManager = components?.manifestManager ?? new ManifestManager(logInstance);
-        const branchManager = components?.branchManager ?? new BranchManager(logInstance);
+        const manifestManager = components?.manifestManager ?? new ManifestManager(log);
+        const branchManager = components?.branchManager ?? new BranchManager(log);
         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);
+            new AuthOptionsBuilder(tokenManager, log, components?.envToken);
+        const repositorySession = components?.repositorySession ?? new RepositorySession(factory, log);
+        const commitPushManager = components?.commitPushManager ?? new CommitPushManager(log);
+        const prMergeHandler = components?.prMergeHandler ?? new PRMergeHandler(log);
         this.fileSyncOrchestrator =
             components?.fileSyncOrchestrator ??
-                new FileSyncOrchestrator(fileWriter, manifestManager, logInstance);
+                new FileSyncOrchestrator(fileWriter, manifestManager, log);
         this.syncWorkflow =
             components?.syncWorkflow ??
-                new SyncWorkflow(authOptionsBuilder, repositorySession, branchManager, commitPushManager, prMergeHandler, logInstance);
+                new SyncWorkflow(authOptionsBuilder, repositorySession, branchManager, commitPushManager, prMergeHandler, log);
     }
     async process(repoConfig, repoInfo, options) {
         const strategy = new FileSyncStrategy(this.fileSyncOrchestrator);

package/dist/sync/repository-session.js

@@ -8,7 +8,8 @@ export class RepositorySession {
     }
     async setup(repoInfo, options) {
         const { workDir, dryRun, retries, authOptions } = options;
-        const gitOps = this.gitOpsFactory({ workDir, dryRun }, authOptions, retries);
+        const { executor } = options;
+        const gitOps = this.gitOpsFactory({ workDir, dryRun, executor }, authOptions, retries);
         this.log.debug("Cleaning workspace...");
         gitOps.cleanWorkspace();
         this.log.debug("Cloning repository...");