@aspruyt/xfg 3.7.5 → 3.7.7

package/dist/settings/rulesets/diff-algorithm.js

@@ -0,0 +1,166 @@
+// src/settings/rulesets/diff-algorithm.ts
+// =============================================================================
+// Helpers
+// =============================================================================
+export function isObject(val) {
+    return val !== null && typeof val === "object" && !Array.isArray(val);
+}
+export function deepEqual(a, b) {
+    if (a === b)
+        return true;
+    if (a === null || b === null || a === undefined || b === undefined)
+        return a === b;
+    if (typeof a !== typeof b)
+        return false;
+    if (Array.isArray(a) && Array.isArray(b)) {
+        if (a.length !== b.length)
+            return false;
+        return a.every((val, i) => deepEqual(val, b[i]));
+    }
+    if (isObject(a) && isObject(b)) {
+        const keysA = Object.keys(a);
+        const keysB = Object.keys(b);
+        if (keysA.length !== keysB.length)
+            return false;
+        return keysA.every((key) => deepEqual(a[key], b[key]));
+    }
+    return false;
+}
+export function isArrayOfObjects(arr) {
+    return arr.length > 0 && arr.every((item) => isObject(item));
+}
+// =============================================================================
+// Property Diff Algorithm
+// =============================================================================
+/**
+ * Recursively compute property-level diffs between two objects.
+ */
+export function computePropertyDiffs(current, desired, parentPath = []) {
+    const diffs = [];
+    const allKeys = new Set([...Object.keys(current), ...Object.keys(desired)]);
+    for (const key of allKeys) {
+        const path = [...parentPath, key];
+        const currentVal = current[key];
+        const desiredVal = desired[key];
+        if (!(key in current)) {
+            // Added property
+            diffs.push({ path, action: "add", newValue: desiredVal });
+        }
+        else if (!(key in desired)) {
+            // Removed property
+            diffs.push({ path, action: "remove", oldValue: currentVal });
+        }
+        else if (!deepEqual(currentVal, desiredVal)) {
+            // Changed property
+            if (isObject(currentVal) && isObject(desiredVal)) {
+                // Recurse into nested objects
+                diffs.push(...computePropertyDiffs(currentVal, desiredVal, path));
+            }
+            else if (Array.isArray(currentVal) &&
+                Array.isArray(desiredVal) &&
+                isArrayOfObjects(currentVal) &&
+                isArrayOfObjects(desiredVal)) {
+                // Recurse into arrays of objects
+                diffs.push(...diffObjectArrays(currentVal, desiredVal, path));
+            }
+            else {
+                diffs.push({
+                    path,
+                    action: "change",
+                    oldValue: currentVal,
+                    newValue: desiredVal,
+                });
+            }
+        }
+        // Unchanged properties are not included
+    }
+    return diffs;
+}
+// =============================================================================
+// Array Diffing
+// =============================================================================
+/**
+ * Diff two arrays of objects by matching items on `type` field (or by index).
+ */
+export function diffObjectArrays(currentArr, desiredArr, parentPath) {
+    const diffs = [];
+    const hasType = desiredArr.every((item) => isObject(item) && "type" in item);
+    if (hasType) {
+        // Match by type field
+        const currentByType = new Map();
+        for (let i = 0; i < currentArr.length; i++) {
+            const item = currentArr[i];
+            const type = item.type;
+            if (type)
+                currentByType.set(type, { item, index: i });
+        }
+        const matchedTypes = new Set();
+        for (let i = 0; i < desiredArr.length; i++) {
+            const desiredItem = desiredArr[i];
+            const type = desiredItem.type;
+            const label = `[${i}] (${type})`;
+            const currentEntry = currentByType.get(type);
+            if (currentEntry) {
+                matchedTypes.add(type);
+                // Recurse into matched pair
+                const itemDiffs = computePropertyDiffs(currentEntry.item, desiredItem, [
+                    ...parentPath,
+                    label,
+                ]);
+                diffs.push(...itemDiffs);
+            }
+            else {
+                // New item in desired
+                diffs.push({
+                    path: [...parentPath, label],
+                    action: "add",
+                    newValue: desiredItem,
+                });
+            }
+        }
+        // Items in current but not in desired
+        for (const [type, entry] of currentByType) {
+            if (!matchedTypes.has(type)) {
+                diffs.push({
+                    path: [...parentPath, `[${entry.index}] (${type})`],
+                    action: "remove",
+                    oldValue: entry.item,
+                });
+            }
+        }
+    }
+    else {
+        // Fallback: match by index
+        const maxLen = Math.max(currentArr.length, desiredArr.length);
+        for (let i = 0; i < maxLen; i++) {
+            const label = `[${i}]`;
+            if (i >= currentArr.length) {
+                diffs.push({
+                    path: [...parentPath, label],
+                    action: "add",
+                    newValue: desiredArr[i],
+                });
+            }
+            else if (i >= desiredArr.length) {
+                diffs.push({
+                    path: [...parentPath, label],
+                    action: "remove",
+                    oldValue: currentArr[i],
+                });
+            }
+            else if (isObject(currentArr[i]) && isObject(desiredArr[i])) {
+                const itemDiffs = computePropertyDiffs(currentArr[i], desiredArr[i], [...parentPath, label]);
+                diffs.push(...itemDiffs);
+            }
+            else if (!deepEqual(currentArr[i], desiredArr[i])) {
+                diffs.push({
+                    path: [...parentPath, label],
+                    action: "change",
+                    oldValue: currentArr[i],
+                    newValue: desiredArr[i],
+                });
+            }
+        }
+    }
+    return diffs;
+}

package/dist/{ruleset-diff.d.ts → settings/rulesets/diff.d.ts}

@@ -1,5 +1,5 @@
-import { type Ruleset } from "./config.js";
-import type { GitHubRuleset } from "./strategies/github-ruleset-strategy.js";
+import { type Ruleset } from "../../config/index.js";
+import type { GitHubRuleset } from "./github-ruleset-strategy.js";
 export type RulesetAction = "create" | "update" | "delete" | "unchanged";
 export interface RulesetChange {
     action: RulesetAction;

package/dist/{ruleset-diff.js → settings/rulesets/diff.js}

@@ -1,4 +1,4 @@
-import { RULESET_COMPARABLE_FIELDS } from "./config.js";
+import { RULESET_COMPARABLE_FIELDS } from "../../config/index.js";
 // =============================================================================
 // Normalization (for comparison)
 // =============================================================================

package/dist/{ruleset-plan-formatter.d.ts → settings/rulesets/formatter.d.ts}

@@ -1,11 +1,7 @@
-import { type RulesetChange, type RulesetAction } from "./ruleset-diff.js";
-export type DiffAction = "add" | "change" | "remove";
-export interface PropertyDiff {
-    path: string[];
-    action: DiffAction;
-    oldValue?: unknown;
-    newValue?: unknown;
-}
+import { type RulesetChange, type RulesetAction } from "./diff.js";
+import { type PropertyDiff } from "./index.js";
+export type { DiffAction, PropertyDiff } from "./index.js";
+export { computePropertyDiffs } from "./index.js";
 export interface RulesetPlanEntry {
     name: string;
     action: RulesetAction;
@@ -24,10 +20,6 @@ export interface RulesetPlanResult {
     unchanged: number;
     entries: RulesetPlanEntry[];
 }
-/**
- * Recursively compute property-level diffs between two objects.
- */
-export declare function computePropertyDiffs(current: Record<string, unknown>, desired: Record<string, unknown>, parentPath?: string[]): PropertyDiff[];
 /**
  * Format property diffs as an indented tree structure.
  */

package/dist/{ruleset-plan-formatter.js → settings/rulesets/formatter.js}

@@ -1,168 +1,7 @@
-// src/ruleset-plan-formatter.ts
 import chalk from "chalk";
-import { projectToDesiredShape, normalizeRuleset, } from "./ruleset-diff.js";
-// =============================================================================
-// Property Diff Algorithm
-// =============================================================================
-/**
- * Recursively compute property-level diffs between two objects.
- */
-export function computePropertyDiffs(current, desired, parentPath = []) {
-    const diffs = [];
-    const allKeys = new Set([...Object.keys(current), ...Object.keys(desired)]);
-    for (const key of allKeys) {
-        const path = [...parentPath, key];
-        const currentVal = current[key];
-        const desiredVal = desired[key];
-        if (!(key in current)) {
-            // Added property
-            diffs.push({ path, action: "add", newValue: desiredVal });
-        }
-        else if (!(key in desired)) {
-            // Removed property
-            diffs.push({ path, action: "remove", oldValue: currentVal });
-        }
-        else if (!deepEqual(currentVal, desiredVal)) {
-            // Changed property
-            if (isObject(currentVal) && isObject(desiredVal)) {
-                // Recurse into nested objects
-                diffs.push(...computePropertyDiffs(currentVal, desiredVal, path));
-            }
-            else if (Array.isArray(currentVal) &&
-                Array.isArray(desiredVal) &&
-                isArrayOfObjects(currentVal) &&
-                isArrayOfObjects(desiredVal)) {
-                // Recurse into arrays of objects
-                diffs.push(...diffObjectArrays(currentVal, desiredVal, path));
-            }
-            else {
-                diffs.push({
-                    path,
-                    action: "change",
-                    oldValue: currentVal,
-                    newValue: desiredVal,
-                });
-            }
-        }
-        // Unchanged properties are not included
-    }
-    return diffs;
-}
-// =============================================================================
-// Helpers
-// =============================================================================
-function isObject(val) {
-    return val !== null && typeof val === "object" && !Array.isArray(val);
-}
-function deepEqual(a, b) {
-    if (a === b)
-        return true;
-    if (a === null || b === null || a === undefined || b === undefined)
-        return a === b;
-    if (typeof a !== typeof b)
-        return false;
-    if (Array.isArray(a) && Array.isArray(b)) {
-        if (a.length !== b.length)
-            return false;
-        return a.every((val, i) => deepEqual(val, b[i]));
-    }
-    if (isObject(a) && isObject(b)) {
-        const keysA = Object.keys(a);
-        const keysB = Object.keys(b);
-        if (keysA.length !== keysB.length)
-            return false;
-        return keysA.every((key) => deepEqual(a[key], b[key]));
-    }
-    return false;
-}
-function isArrayOfObjects(arr) {
-    return arr.length > 0 && arr.every((item) => isObject(item));
-}
-/**
- * Diff two arrays of objects by matching items on `type` field (or by index).
- */
-function diffObjectArrays(currentArr, desiredArr, parentPath) {
-    const diffs = [];
-    const hasType = desiredArr.every((item) => isObject(item) && "type" in item);
-    if (hasType) {
-        // Match by type field
-        const currentByType = new Map();
-        for (let i = 0; i < currentArr.length; i++) {
-            const item = currentArr[i];
-            const type = item.type;
-            if (type)
-                currentByType.set(type, { item, index: i });
-        }
-        const matchedTypes = new Set();
-        for (let i = 0; i < desiredArr.length; i++) {
-            const desiredItem = desiredArr[i];
-            const type = desiredItem.type;
-            const label = `[${i}] (${type})`;
-            const currentEntry = currentByType.get(type);
-            if (currentEntry) {
-                matchedTypes.add(type);
-                // Recurse into matched pair
-                const itemDiffs = computePropertyDiffs(currentEntry.item, desiredItem, [
-                    ...parentPath,
-                    label,
-                ]);
-                diffs.push(...itemDiffs);
-            }
-            else {
-                // New item in desired
-                diffs.push({
-                    path: [...parentPath, label],
-                    action: "add",
-                    newValue: desiredItem,
-                });
-            }
-        }
-        // Items in current but not in desired
-        for (const [type, entry] of currentByType) {
-            if (!matchedTypes.has(type)) {
-                diffs.push({
-                    path: [...parentPath, `[${entry.index}] (${type})`],
-                    action: "remove",
-                    oldValue: entry.item,
-                });
-            }
-        }
-    }
-    else {
-        // Fallback: match by index
-        const maxLen = Math.max(currentArr.length, desiredArr.length);
-        for (let i = 0; i < maxLen; i++) {
-            const label = `[${i}]`;
-            if (i >= currentArr.length) {
-                diffs.push({
-                    path: [...parentPath, label],
-                    action: "add",
-                    newValue: desiredArr[i],
-                });
-            }
-            else if (i >= desiredArr.length) {
-                diffs.push({
-                    path: [...parentPath, label],
-                    action: "remove",
-                    oldValue: currentArr[i],
-                });
-            }
-            else if (isObject(currentArr[i]) && isObject(desiredArr[i])) {
-                const itemDiffs = computePropertyDiffs(currentArr[i], desiredArr[i], [...parentPath, label]);
-                diffs.push(...itemDiffs);
-            }
-            else if (!deepEqual(currentArr[i], desiredArr[i])) {
-                diffs.push({
-                    path: [...parentPath, label],
-                    action: "change",
-                    oldValue: currentArr[i],
-                    newValue: desiredArr[i],
-                });
-            }
-        }
-    }
-    return diffs;
-}
+import { projectToDesiredShape, normalizeRuleset, } from "./diff.js";
+import { computePropertyDiffs, isObject, } from "./index.js";
+export { computePropertyDiffs } from "./index.js";
 /**
  * Build a tree structure from flat property diffs.
  */
@@ -372,10 +211,10 @@ function formatFullConfig(ruleset, indent = 2) {
                 lines.push(style.color(`${pad}+ ${key}:`));
                 for (const item of value) {
                     if (typeof item === "object" && item !== null) {
-                        lines.push(style.color(`${pad}    - ${JSON.stringify(item)}`));
+                        lines.push(style.color(`${pad}    + ${JSON.stringify(item)}`));
                     }
                     else {
-                        lines.push(style.color(`${pad}    - ${formatValue(item)}`));
+                        lines.push(style.color(`${pad}    + ${formatValue(item)}`));
                     }
                 }
             }

package/dist/{strategies → settings/rulesets}/github-ruleset-strategy.d.ts

@@ -1,7 +1,7 @@
-import { ICommandExecutor } from "../command-executor.js";
-import { RepoInfo } from "../repo-detector.js";
-import type { Ruleset } from "../config.js";
-import type { IRulesetStrategy } from "./ruleset-strategy.js";
+import { ICommandExecutor } from "../../shared/command-executor.js";
+import { RepoInfo } from "../../shared/repo-detector.js";
+import type { Ruleset } from "../../config/index.js";
+import type { IRulesetStrategy } from "./types.js";
 /**
  * GitHub Ruleset response from API (snake_case).
  */

package/dist/{strategies → settings/rulesets}/github-ruleset-strategy.js

@@ -1,6 +1,6 @@
-import { defaultExecutor } from "../command-executor.js";
-import { isGitHubRepo } from "../repo-detector.js";
-import { escapeShellArg } from "../shell-utils.js";
+import { defaultExecutor, } from "../../shared/command-executor.js";
+import { isGitHubRepo, } from "../../shared/repo-detector.js";
+import { escapeShellArg } from "../../shared/shell-utils.js";
 // =============================================================================
 // Conversion Functions
 // =============================================================================

package/dist/settings/rulesets/index.d.ts

@@ -0,0 +1,6 @@
+export type { IRulesetStrategy } from "./types.js";
+export { computePropertyDiffs, diffObjectArrays, deepEqual, isObject, isArrayOfObjects, type DiffAction, type PropertyDiff, } from "./diff-algorithm.js";
+export { RulesetProcessor, type IRulesetProcessor, type RulesetProcessorOptions, type RulesetProcessorResult, } from "./processor.js";
+export { diffRulesets, normalizeRuleset, projectToDesiredShape, type RulesetAction, type RulesetChange, } from "./diff.js";
+export { formatRulesetPlan, type RulesetPlanResult, type RulesetPlanEntry, } from "./formatter.js";
+export { GitHubRulesetStrategy, configToGitHub, type GitHubRuleset, type GitHubBypassActor, type GitHubRulesetConditions, type GitHubRule, type RulesetStrategyOptions, } from "./github-ruleset-strategy.js";

package/dist/settings/rulesets/index.js

@@ -0,0 +1,10 @@
+// Diff algorithm - property-level diffing for ruleset comparisons
+export { computePropertyDiffs, diffObjectArrays, deepEqual, isObject, isArrayOfObjects, } from "./diff-algorithm.js";
+// Ruleset processor
+export { RulesetProcessor, } from "./processor.js";
+// Ruleset diff
+export { diffRulesets, normalizeRuleset, projectToDesiredShape, } from "./diff.js";
+// Ruleset formatter
+export { formatRulesetPlan, } from "./formatter.js";
+// Ruleset strategies
+export { GitHubRulesetStrategy, configToGitHub, } from "./github-ruleset-strategy.js";

package/dist/{ruleset-processor.d.ts → settings/rulesets/processor.d.ts}

@@ -1,7 +1,7 @@
-import type { RepoConfig } from "./config.js";
-import type { RepoInfo } from "./repo-detector.js";
-import { GitHubRulesetStrategy } from "./strategies/github-ruleset-strategy.js";
-import { RulesetPlanResult } from "./ruleset-plan-formatter.js";
+import type { RepoConfig } from "../../config/index.js";
+import type { RepoInfo } from "../../shared/repo-detector.js";
+import { GitHubRulesetStrategy } from "./github-ruleset-strategy.js";
+import { RulesetPlanResult } from "./formatter.js";
 export interface IRulesetProcessor {
     process(repoConfig: RepoConfig, repoInfo: RepoInfo, options: RulesetProcessorOptions): Promise<RulesetProcessorResult>;
 }

package/dist/{ruleset-processor.js → settings/rulesets/processor.js}

@@ -1,9 +1,9 @@
-import { isGitHubRepo, getRepoDisplayName } from "./repo-detector.js";
-import { GitHubRulesetStrategy, } from "./strategies/github-ruleset-strategy.js";
-import { diffRulesets } from "./ruleset-diff.js";
-import { formatRulesetPlan, } from "./ruleset-plan-formatter.js";
-import { hasGitHubAppCredentials } from "./strategies/index.js";
-import { GitHubAppTokenManager } from "./github-app-token-manager.js";
+import { isGitHubRepo, getRepoDisplayName, } from "../../shared/repo-detector.js";
+import { GitHubRulesetStrategy, } from "./github-ruleset-strategy.js";
+import { diffRulesets } from "./diff.js";
+import { formatRulesetPlan } from "./formatter.js";
+import { hasGitHubAppCredentials } from "../../vcs/index.js";
+import { GitHubAppTokenManager } from "../../vcs/github-app-token-manager.js";
 // =============================================================================
 // Processor Implementation
 // =============================================================================

package/dist/{strategies/ruleset-strategy.d.ts → settings/rulesets/types.d.ts}

@@ -1,5 +1,5 @@
-import type { RepoInfo } from "../repo-detector.js";
-import type { Ruleset } from "../config.js";
+import type { RepoInfo } from "../../shared/repo-detector.js";
+import type { Ruleset } from "../../config/index.js";
 import type { GitHubRuleset, RulesetStrategyOptions } from "./github-ruleset-strategy.js";
 export interface IRulesetStrategy {
     list(repoInfo: RepoInfo, options?: RulesetStrategyOptions): Promise<GitHubRuleset[]>;

package/dist/{command-executor.d.ts → shared/command-executor.d.ts}

@@ -1,3 +1,10 @@
+/**
+ * Options for command execution.
+ */
+export interface ExecOptions {
+    /** Additional environment variables to set for the command */
+    env?: Record<string, string>;
+}
 /**
  * Interface for executing shell commands.
  * Enables dependency injection for testing and alternative implementations.
@@ -7,17 +14,18 @@ export interface ICommandExecutor {
      * Execute a shell command and return the output.
      * @param command The command to execute
      * @param cwd The working directory for the command
+     * @param options Optional execution options (env vars, etc.)
      * @returns Promise resolving to the trimmed stdout output
      * @throws Error if the command fails
      */
-    exec(command: string, cwd: string): Promise<string>;
+    exec(command: string, cwd: string, options?: ExecOptions): Promise<string>;
 }
 /**
  * Default implementation that uses Node.js child_process.execSync.
  * Note: Commands are escaped using escapeShellArg before being passed here.
  */
 export declare class ShellCommandExecutor implements ICommandExecutor {
-    exec(command: string, cwd: string): Promise<string>;
+    exec(command: string, cwd: string, options?: ExecOptions): Promise<string>;
 }
 /**
  * Default executor instance for production use.

package/dist/{command-executor.js → shared/command-executor.js}

@@ -5,12 +5,13 @@ import { sanitizeCredentials } from "./sanitize-utils.js";
  * Note: Commands are escaped using escapeShellArg before being passed here.
  */
 export class ShellCommandExecutor {
-    async exec(command, cwd) {
+    async exec(command, cwd, options) {
         try {
             return execSync(command, {
                 cwd,
                 encoding: "utf-8",
                 stdio: ["pipe", "pipe", "pipe"],
+                env: options?.env ? { ...process.env, ...options.env } : undefined,
             }).trim();
         }
         catch (error) {

package/dist/shared/index.d.ts

@@ -0,0 +1,8 @@
+export { Logger, logger, type ILogger, type LoggerStats } from "./logger.js";
+export { withRetry, isPermanentError, isTransientError, promisify, DEFAULT_PERMANENT_ERROR_PATTERNS, DEFAULT_TRANSIENT_ERROR_PATTERNS, AbortError, type RetryOptions, } from "./retry-utils.js";
+export { ShellCommandExecutor, defaultExecutor, type ICommandExecutor, } from "./command-executor.js";
+export { escapeShellArg } from "./shell-utils.js";
+export { sanitizeCredentials } from "./sanitize-utils.js";
+export { interpolateEnvVars, interpolateEnvVarsInString, interpolateEnvVarsInLines, interpolateContent, type EnvInterpolationOptions, } from "./env.js";
+export { generateWorkspaceName } from "./workspace-utils.js";
+export { detectRepoType, parseGitUrl, getRepoDisplayName, isGitHubRepo, isAzureDevOpsRepo, isGitLabRepo, type RepoType, type RepoInfo, type GitHubRepoInfo, type AzureDevOpsRepoInfo, type GitLabRepoInfo, type RepoDetectorContext, } from "./repo-detector.js";

package/dist/shared/index.js

@@ -0,0 +1,16 @@
+// Logging
+export { Logger, logger } from "./logger.js";
+// Retry utilities
+export { withRetry, isPermanentError, isTransientError, promisify, DEFAULT_PERMANENT_ERROR_PATTERNS, DEFAULT_TRANSIENT_ERROR_PATTERNS, AbortError, } from "./retry-utils.js";
+// Command execution
+export { ShellCommandExecutor, defaultExecutor, } from "./command-executor.js";
+// Shell utilities
+export { escapeShellArg } from "./shell-utils.js";
+// Sanitization
+export { sanitizeCredentials } from "./sanitize-utils.js";
+// Environment
+export { interpolateEnvVars, interpolateEnvVarsInString, interpolateEnvVarsInLines, interpolateContent, } from "./env.js";
+// Workspace utilities
+export { generateWorkspaceName } from "./workspace-utils.js";
+// Repository detection
+export { detectRepoType, parseGitUrl, getRepoDisplayName, isGitHubRepo, isAzureDevOpsRepo, isGitLabRepo, } from "./repo-detector.js";

package/dist/{logger.d.ts → shared/logger.d.ts}

@@ -1,4 +1,4 @@
-import { FileStatus } from "./diff-utils.js";
+import { FileStatus } from "../sync/diff-utils.js";
 export interface ILogger {
     info(message: string): void;
     fileDiff(fileName: string, status: FileStatus, diffLines: string[]): void;

package/dist/{logger.js → shared/logger.js}

@@ -1,5 +1,5 @@
 import chalk from "chalk";
-import { formatStatusBadge } from "./diff-utils.js";
+import { formatStatusBadge } from "../sync/diff-utils.js";
 export class Logger {
     stats = {
         total: 0,

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

@@ -0,0 +1,12 @@
+import { RepoInfo } from "../shared/repo-detector.js";
+import { ILogger } from "../shared/logger.js";
+import { GitHubAppTokenManager } from "../vcs/github-app-token-manager.js";
+import type { AuthResult, IAuthOptionsBuilder } from "./types.js";
+export declare class AuthOptionsBuilder implements IAuthOptionsBuilder {
+    private readonly tokenManager;
+    private readonly log;
+    constructor(tokenManager: GitHubAppTokenManager | null, log: ILogger);
+    resolve(repoInfo: RepoInfo, repoName: string): Promise<AuthResult>;
+    private getInstallationToken;
+    private buildAuthOptions;
+}

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

@@ -0,0 +1,54 @@
+import { isGitHubRepo, } from "../shared/repo-detector.js";
+export class AuthOptionsBuilder {
+    tokenManager;
+    log;
+    constructor(tokenManager, log) {
+        this.tokenManager = tokenManager;
+        this.log = log;
+    }
+    async resolve(repoInfo, repoName) {
+        // 1. Get installation token if GitHub App configured
+        const installationToken = await this.getInstallationToken(repoInfo);
+        // 2. Handle "no installation found" case
+        if (installationToken === null) {
+            return {
+                skipResult: {
+                    success: true,
+                    repoName,
+                    message: `No GitHub App installation found for ${repoInfo.owner}`,
+                    skipped: true,
+                },
+            };
+        }
+        // 3. Build effective token (installation token or PAT fallback)
+        const token = installationToken ??
+            (isGitHubRepo(repoInfo) ? process.env.GH_TOKEN : undefined);
+        // 4. Build auth options if we have a token
+        const authOptions = token
+            ? this.buildAuthOptions(repoInfo, token)
+            : undefined;
+        return { token, authOptions };
+    }
+    async getInstallationToken(repoInfo) {
+        if (!this.tokenManager || !isGitHubRepo(repoInfo)) {
+            return undefined;
+        }
+        try {
+            return await this.tokenManager.getTokenForRepo(repoInfo);
+        }
+        catch (error) {
+            this.log.info(`Warning: Failed to get GitHub App token: ${error instanceof Error ? error.message : String(error)}`);
+            return undefined;
+        }
+    }
+    buildAuthOptions(repoInfo, token) {
+        return {
+            token,
+            host: isGitHubRepo(repoInfo)
+                ? repoInfo.host
+                : "github.com",
+            owner: repoInfo.owner,
+            repo: repoInfo.repo,
+        };
+    }
+}

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

@@ -0,0 +1,7 @@
+import type { IBranchManager, BranchSetupOptions } from "./types.js";
+/**
+ * Handles branch creation and existing PR cleanup.
+ */
+export declare class BranchManager implements IBranchManager {
+    setupBranch(options: BranchSetupOptions): Promise<void>;
+}