@aspruyt/xfg 5.1.3 → 5.1.5

package/dist/output/unified-summary.js

@@ -1,5 +1,6 @@
 import { hasLifecycleChanges } from "./lifecycle-report.js";
 import { writeGitHubStepSummary } from "./github-summary.js";
+import { renderSyncLines } from "./sync-report.js";
 import { renderRepoSettingsDiffLines, formatCountEntry, } from "./settings-report.js";
 // =============================================================================
 // Helpers
@@ -130,25 +131,6 @@ function renderLifecycleLines(lcAction, diffLines) {
         }
     }
 }
-export function renderSyncLines(syncRepo, diffLines) {
-    for (const file of syncRepo.files) {
-        if (file.action === "create") {
-            diffLines.push(`+ ${file.path}`);
-        }
-        else if (file.action === "update") {
-            diffLines.push(`! ${file.path}`);
-        }
-        else if (file.action === "delete") {
-            diffLines.push(`- ${file.path}`);
-        }
-        if (file.diffLines) {
-            diffLines.push(...file.diffLines);
-        }
-    }
-    if (syncRepo.error) {
-        diffLines.push(`- Error: ${syncRepo.error}`);
-    }
-}
 // =============================================================================
 // Markdown Formatter
 // =============================================================================

package/dist/settings/base-processor.d.ts

@@ -35,6 +35,14 @@ interface SettingsGuards<TOptions extends BaseProcessorOptions, TResult extends
 export declare function withGitHubGuards<TOptions extends BaseProcessorOptions, TResult extends BaseProcessorResult>(repoConfig: RepoConfig, repoInfo: RepoInfo, options: TOptions, guards: SettingsGuards<TOptions, TResult>): Promise<TResult>;
 /** Common action literals shared by all settings processors. */
 export type SettingsAction = "create" | "update" | "delete" | "unchanged";
+/** Actions that represent an actual change (excludes "unchanged"). */
+export type ActiveAction = Exclude<SettingsAction, "unchanged">;
+/** Type predicate that narrows entries with an active (non-"unchanged") action. */
+export declare function isActiveAction<T extends {
+    action: SettingsAction;
+}>(entry: T): entry is T & {
+    action: ActiveAction;
+};
 export interface ChangeCounts {
     create: number;
     update: number;

package/dist/settings/base-processor.js

@@ -6,6 +6,9 @@ import { toErrorMessage } from "../shared/type-guards.js";
  */
 export async function withGitHubGuards(repoConfig, repoInfo, options, guards) {
     const repoName = getRepoDisplayName(repoInfo);
+    // Safe cast: all TResult subtypes (RulesetProcessorResult, LabelsProcessorResult,
+    // RepoSettingsProcessorResult) only extend BaseProcessorResult with optional fields.
+    // If adding a new processor result type, ensure all extension fields are optional.
     if (!isGitHubRepo(repoInfo)) {
         return {
             success: true,
@@ -34,6 +37,10 @@ export async function withGitHubGuards(repoConfig, repoInfo, options, guards) {
         };
     }
 }
+/** Type predicate that narrows entries with an active (non-"unchanged") action. */
+export function isActiveAction(entry) {
+    return entry.action !== "unchanged";
+}
 /**
  * Count actions from a diff result array.
  * Works with any change type that has an `action` field.

package/dist/settings/index.d.ts

@@ -1,4 +1,4 @@
-export { type ISettingsProcessor, type SettingsAction, } from "./base-processor.js";
-export { type PropertyDiff, formatPropertyTree, type RulesetPlanEntry, RulesetProcessor, type IRulesetProcessor, GitHubRulesetStrategy, } from "./rulesets/index.js";
+export { type BaseProcessorResult, type ISettingsProcessor, countActions, isActiveAction, } from "./base-processor.js";
+export { type PropertyDiff, type RulesetPlanEntry, RulesetProcessor, type IRulesetProcessor, GitHubRulesetStrategy, } from "./rulesets/index.js";
 export { RepoSettingsProcessor, type IRepoSettingsProcessor, type RepoSettingsPlanEntry, GitHubRepoSettingsStrategy, } from "./repo-settings/index.js";
 export { type LabelsPlanEntry, LabelsProcessor, type ILabelsProcessor, GitHubLabelsStrategy, } from "./labels/index.js";

package/dist/settings/index.js

@@ -1,5 +1,7 @@
+// Base processor
+export { countActions, isActiveAction, } from "./base-processor.js";
 // Rulesets
-export { formatPropertyTree, RulesetProcessor, GitHubRulesetStrategy, } from "./rulesets/index.js";
+export { RulesetProcessor, GitHubRulesetStrategy, } from "./rulesets/index.js";
 // Repo settings
 export { RepoSettingsProcessor, GitHubRepoSettingsStrategy, } from "./repo-settings/index.js";
 // Labels

package/dist/settings/labels/converter.d.ts

@@ -1,4 +1,4 @@
-import type { Label } from "../../config/types.js";
+import type { Label } from "../../config/index.js";
 interface GitHubLabelPayload {
     name: string;
     new_name?: string;

package/dist/settings/labels/diff.d.ts

@@ -1,4 +1,4 @@
-import type { Label } from "../../config/types.js";
+import type { Label } from "../../config/index.js";
 import type { GitHubLabel } from "./types.js";
 import type { SettingsAction } from "../base-processor.js";
 export type LabelAction = SettingsAction;

package/dist/settings/labels/formatter.d.ts

@@ -1,5 +1,5 @@
 import type { LabelChange, LabelAction } from "./diff.js";
-import type { Label } from "../../config/types.js";
+import type { Label } from "../../config/index.js";
 export interface LabelsPlanEntry {
     name: string;
     action: LabelAction;

package/dist/settings/repo-settings/processor.js

@@ -57,12 +57,13 @@ export class RepoSettingsProcessor {
             });
         }
         // Apply changes - only send settings that actually changed
-        const changedSettings = changes.reduce((acc, change) => {
+        const changedSettings = {};
+        for (const change of changes) {
             if (change.action !== "unchanged") {
-                acc[change.property] = change.newValue;
+                changedSettings[change.property] =
+                    change.newValue;
             }
-            return acc;
-        }, {});
+        }
         await this.applyChanges(githubRepo, changedSettings, strategyOptions);
         const appliedCount = Object.keys(changedSettings).length;
         return buildApplyResult(repoName, changeCounts, appliedCount, {
@@ -94,7 +95,10 @@ export class RepoSettingsProcessor {
     }
     validateSecuritySettings(desiredSettings, currentSettings) {
         const errors = [];
-        const isPublic = currentSettings.visibility === "public";
+        // Use desired visibility if specified (repo may be transitioning to public),
+        // otherwise fall back to current visibility
+        const effectiveVisibility = desiredSettings.visibility ?? currentSettings.visibility;
+        const isPublic = effectiveVisibility === "public";
         // privateVulnerabilityReporting is only available on public repos
         if (desiredSettings.privateVulnerabilityReporting === true && !isPublic) {
             errors.push("privateVulnerabilityReporting is only available for public repositories");

package/dist/settings/rulesets/formatter.js

@@ -121,46 +121,52 @@ function getActionStyle(action) {
 /**
  * Render a leaf tree node (no children) with its value.
  */
-function renderLeafNode(child, style, indentStr, indent) {
+function hasComplexValue(value) {
+    return (isPlainObject(value) ||
+        (Array.isArray(value) && value.some((v) => isPlainObject(v))));
+}
+function renderComplexLeaf(child, style, indentStr, indent) {
     const lines = [];
-    const hasComplexNew = isPlainObject(child.newValue) ||
-        (Array.isArray(child.newValue) &&
-            child.newValue.some((v) => isPlainObject(v)));
-    const hasComplexOld = isPlainObject(child.oldValue) ||
-        (Array.isArray(child.oldValue) &&
-            child.oldValue.some((v) => isPlainObject(v)));
-    if (child.action === "add" && hasComplexNew) {
+    if (child.action === "add") {
         lines.push(style.color(`${indentStr}${style.symbol} ${child.name}:`));
         lines.push(...renderNestedValue(child.newValue, child.action, indent + 1));
     }
-    else if (child.action === "remove" && hasComplexOld) {
+    else if (child.action === "remove") {
         lines.push(style.color(`${indentStr}${style.symbol} ${child.name} (removed):`));
         lines.push(...renderNestedValue(child.oldValue, child.action, indent + 1));
     }
-    else if (child.action === "change" && (hasComplexNew || hasComplexOld)) {
+    else {
         lines.push(style.color(`${indentStr}${style.symbol} ${child.name}:`));
-        if (hasComplexOld) {
+        if (hasComplexValue(child.oldValue)) {
             lines.push(...renderNestedValue(child.oldValue, "remove", indent + 1));
         }
-        if (hasComplexNew) {
+        if (hasComplexValue(child.newValue)) {
             lines.push(...renderNestedValue(child.newValue, "add", indent + 1));
         }
     }
-    else {
-        let valuePart = "";
-        if (child.action === "change") {
-            valuePart = `: ${formatValue(child.oldValue)} → ${formatValue(child.newValue)}`;
-        }
-        else if (child.action === "add") {
-            valuePart = `: ${formatValue(child.newValue)}`;
-        }
-        else if (child.action === "remove") {
-            valuePart = ` (was: ${formatValue(child.oldValue)})`;
-        }
-        lines.push(style.color(`${indentStr}${style.symbol} ${child.name}${valuePart}`));
-    }
     return lines;
 }
+function renderSimpleLeaf(child, style, indentStr) {
+    let valuePart = "";
+    if (child.action === "change") {
+        valuePart = `: ${formatValue(child.oldValue)} → ${formatValue(child.newValue)}`;
+    }
+    else if (child.action === "add") {
+        valuePart = `: ${formatValue(child.newValue)}`;
+    }
+    else if (child.action === "remove") {
+        valuePart = ` (was: ${formatValue(child.oldValue)})`;
+    }
+    return style.color(`${indentStr}${style.symbol} ${child.name}${valuePart}`);
+}
+function renderLeafNode(child, style, indentStr, indent) {
+    const isComplex = (child.action !== "remove" && hasComplexValue(child.newValue)) ||
+        (child.action !== "add" && hasComplexValue(child.oldValue));
+    if (isComplex) {
+        return renderComplexLeaf(child, style, indentStr, indent);
+    }
+    return [renderSimpleLeaf(child, style, indentStr)];
+}
 /**
  * Recursively render tree nodes to formatted lines.
  */
@@ -198,85 +204,91 @@ export function formatPropertyTree(diffs) {
  * Delegates to renderNestedObject which handles recursive rendering.
  */
 function formatFullConfig(ruleset, indent = 2) {
-    return renderNestedObject(ruleset, "add", indent);
+    // Object.entries works on any object; the cast avoids a double assertion
+    const entries = Object.entries(ruleset);
+    return renderNestedObject(Object.fromEntries(entries), "add", indent);
 }
 /**
  * Format ruleset changes as a Terraform-style plan.
  */
 export function formatRulesetPlan(changes) {
     const lines = [];
-    let creates = 0;
-    let updates = 0;
-    let deletes = 0;
-    let unchanged = 0;
     const entries = [];
-    // Group by action type
-    const createChanges = changes.filter((c) => c.action === "create");
-    const updateChanges = changes.filter((c) => c.action === "update");
-    const deleteChanges = changes.filter((c) => c.action === "delete");
-    const unchangedItems = changes.filter((c) => c.action === "unchanged");
-    creates = createChanges.length;
-    updates = updateChanges.length;
-    deletes = deleteChanges.length;
-    unchanged = unchangedItems.length;
-    if (createChanges.length > 0) {
-        lines.push(chalk.bold("  Create:"));
-        for (const change of createChanges) {
-            lines.push(chalk.green(`    + ruleset "${change.name}"`));
-            if (change.desired) {
-                lines.push(...formatFullConfig(change.desired, 2));
+    // Group by action in a single pass
+    const grouped = {
+        create: [],
+        update: [],
+        delete: [],
+        unchanged: [],
+    };
+    for (const c of changes) {
+        grouped[c.action].push(c);
+    }
+    for (const change of grouped.create) {
+        if (grouped.create.indexOf(change) === 0) {
+            lines.push(chalk.bold("  Create:"));
+        }
+        lines.push(chalk.green(`    + ruleset "${change.name}"`));
+        if (change.desired) {
+            lines.push(...formatFullConfig(change.desired, 2));
+        }
+        const propertyCount = change.desired
+            ? Object.keys(change.desired).length
+            : 0;
+        entries.push({
+            name: change.name,
+            action: "create",
+            propertyCount,
+            config: change.desired,
+        });
+        lines.push("");
+    }
+    for (const change of grouped.update) {
+        if (grouped.update.indexOf(change) === 0) {
+            lines.push(chalk.bold("  Update:"));
+        }
+        lines.push(chalk.yellow(`    ~ ruleset "${change.name}"`));
+        if (change.current && change.desired) {
+            const currentNorm = normalizeRuleset(change.current);
+            const desiredNorm = normalizeRuleset(change.desired);
+            const projectedCurrent = projectToDesiredShape(currentNorm, desiredNorm);
+            const diffs = computePropertyDiffs(projectedCurrent, desiredNorm);
+            const treeLines = formatPropertyTree(diffs);
+            for (const line of treeLines) {
+                lines.push(`        ${line}`);
             }
-            const propertyCount = change.desired
-                ? Object.keys(change.desired).length
-                : 0;
+            const added = diffs.filter((d) => d.action === "add").length;
+            const changed = diffs.filter((d) => d.action === "change").length;
+            const removed = diffs.filter((d) => d.action === "remove").length;
             entries.push({
                 name: change.name,
-                action: "create",
-                propertyCount,
-                config: change.desired,
+                action: "update",
+                propertyChanges: { added, changed, removed },
+                propertyDiffs: diffs,
             });
-            lines.push(""); // Blank line between rulesets
         }
-    }
-    if (updateChanges.length > 0) {
-        lines.push(chalk.bold("  Update:"));
-        for (const change of updateChanges) {
-            lines.push(chalk.yellow(`    ~ ruleset "${change.name}"`));
-            if (change.current && change.desired) {
-                const currentNorm = normalizeRuleset(change.current);
-                const desiredNorm = normalizeRuleset(change.desired);
-                const projectedCurrent = projectToDesiredShape(currentNorm, desiredNorm);
-                const diffs = computePropertyDiffs(projectedCurrent, desiredNorm);
-                const treeLines = formatPropertyTree(diffs);
-                for (const line of treeLines) {
-                    lines.push(`        ${line}`);
-                }
-                const added = diffs.filter((d) => d.action === "add").length;
-                const changed = diffs.filter((d) => d.action === "change").length;
-                const removed = diffs.filter((d) => d.action === "remove").length;
-                entries.push({
-                    name: change.name,
-                    action: "update",
-                    propertyChanges: { added, changed, removed },
-                    propertyDiffs: diffs,
-                });
-            }
-            else {
-                entries.push({ name: change.name, action: "update" });
-            }
-            lines.push(""); // Blank line between rulesets
+        else {
+            entries.push({ name: change.name, action: "update" });
         }
+        lines.push("");
     }
-    if (deleteChanges.length > 0) {
+    if (grouped.delete.length > 0) {
         lines.push(chalk.bold("  Delete:"));
-        for (const change of deleteChanges) {
+        for (const change of grouped.delete) {
             lines.push(chalk.red(`    - ruleset "${change.name}"`));
             entries.push({ name: change.name, action: "delete" });
         }
-        lines.push(""); // Blank line after deletes
+        lines.push("");
     }
-    for (const change of unchangedItems) {
+    for (const change of grouped.unchanged) {
         entries.push({ name: change.name, action: "unchanged" });
     }
-    return { lines, creates, updates, deletes, unchanged, entries };
+    return {
+        lines,
+        creates: grouped.create.length,
+        updates: grouped.update.length,
+        deletes: grouped.delete.length,
+        unchanged: grouped.unchanged.length,
+        entries,
+    };
 }

package/dist/settings/rulesets/github-ruleset-strategy.d.ts

@@ -2,7 +2,7 @@ import { ICommandExecutor } from "../../shared/command-executor.js";
 import { RepoInfo } from "../../shared/repo-detector.js";
 import { type GhApiOptions } from "../../shared/gh-api-utils.js";
 import type { Ruleset } from "../../config/index.js";
-import type { IRulesetStrategy, GitHubRuleset, GitHubBypassActor, GitHubRulesetConditions, GitHubRule } from "./types.js";
+import type { IRulesetStrategy, GitHubRuleset, GitHubBypassActor, GitHubRulesetConditions, GitHubRule, RulesetUpdateParams } from "./types.js";
 /**
  * Converts camelCase config ruleset to snake_case GitHub API format.
  */
@@ -25,7 +25,7 @@ export declare class GitHubRulesetStrategy implements IRulesetStrategy {
     list(repoInfo: RepoInfo, options?: GhApiOptions): Promise<GitHubRuleset[]>;
     get(repoInfo: RepoInfo, rulesetId: number, options?: GhApiOptions): Promise<GitHubRuleset>;
     create(repoInfo: RepoInfo, name: string, ruleset: Ruleset, options?: GhApiOptions): Promise<GitHubRuleset>;
-    update(repoInfo: RepoInfo, rulesetId: number, name: string, ruleset: Ruleset, options?: GhApiOptions): Promise<GitHubRuleset>;
+    update(repoInfo: RepoInfo, params: RulesetUpdateParams, options?: GhApiOptions): Promise<GitHubRuleset>;
     delete(repoInfo: RepoInfo, rulesetId: number, options?: GhApiOptions): Promise<void>;
 }
 export {};

package/dist/settings/rulesets/github-ruleset-strategy.js

@@ -118,11 +118,14 @@ export class GitHubRulesetStrategy {
         const result = await this.api.call("POST", endpoint, { payload, options });
         return parseApiJson(result, "ruleset response");
     }
-    async update(repoInfo, rulesetId, name, ruleset, options) {
+    async update(repoInfo, params, options) {
         assertGitHubRepo(repoInfo, "GitHub Ruleset strategy");
-        const endpoint = `/repos/${repoInfo.owner}/${repoInfo.repo}/rulesets/${rulesetId}`;
-        const payload = configToGitHub(name, ruleset);
-        const result = await this.api.call("PUT", endpoint, { payload, options });
+        const endpoint = `/repos/${repoInfo.owner}/${repoInfo.repo}/rulesets/${params.rulesetId}`;
+        const payload = configToGitHub(params.name, params.ruleset);
+        const result = await this.api.call("PUT", endpoint, {
+            payload,
+            options,
+        });
         return parseApiJson(result, "ruleset response");
     }
     async delete(repoInfo, rulesetId, options) {

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

@@ -1,4 +1,4 @@
 export { computePropertyDiffs, deepEqual, isArrayOfObjects, type PropertyDiff, } from "./diff-algorithm.js";
-export { formatPropertyTree, type RulesetPlanEntry } from "./formatter.js";
+export { type RulesetPlanEntry } from "./formatter.js";
 export { RulesetProcessor, type IRulesetProcessor } from "./processor.js";
 export { GitHubRulesetStrategy } from "./github-ruleset-strategy.js";

package/dist/settings/rulesets/index.js

@@ -1,7 +1,5 @@
 // Diff algorithm - property-level diffing for ruleset comparisons
 export { computePropertyDiffs, deepEqual, isArrayOfObjects, } from "./diff-algorithm.js";
-// Formatter
-export { formatPropertyTree } from "./formatter.js";
 // Processor
 export { RulesetProcessor } from "./processor.js";
 // Strategy

package/dist/settings/rulesets/processor.js

@@ -56,7 +56,11 @@ export class RulesetProcessor {
                     break;
                 case "update":
                     if (change.rulesetId !== undefined && change.desired) {
-                        await this.strategy.update(githubRepo, change.rulesetId, change.name, change.desired, strategyOptions);
+                        await this.strategy.update(githubRepo, {
+                            rulesetId: change.rulesetId,
+                            name: change.name,
+                            ruleset: change.desired,
+                        }, strategyOptions);
                         appliedCount++;
                     }
                     break;

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

@@ -30,10 +30,15 @@ export interface GitHubRule {
     type: string;
     parameters?: Record<string, unknown>;
 }
+export interface RulesetUpdateParams {
+    rulesetId: number;
+    name: string;
+    ruleset: Ruleset;
+}
 export interface IRulesetStrategy {
     list(repoInfo: RepoInfo, options?: GhApiOptions): Promise<GitHubRuleset[]>;
     get(repoInfo: RepoInfo, rulesetId: number, options?: GhApiOptions): Promise<GitHubRuleset>;
     create(repoInfo: RepoInfo, name: string, ruleset: Ruleset, options?: GhApiOptions): Promise<GitHubRuleset>;
-    update(repoInfo: RepoInfo, rulesetId: number, name: string, ruleset: Ruleset, options?: GhApiOptions): Promise<GitHubRuleset>;
+    update(repoInfo: RepoInfo, params: RulesetUpdateParams, options?: GhApiOptions): Promise<GitHubRuleset>;
     delete(repoInfo: RepoInfo, rulesetId: number, options?: GhApiOptions): Promise<void>;
 }

package/dist/shared/gh-api-utils.d.ts

@@ -31,7 +31,7 @@ export declare class GhApiClient {
     constructor(executor: ICommandExecutor, retries: number, cwd: string);
     call(method: HttpMethod, endpoint: string, params?: GhApiCallParams): Promise<string>;
 }
-export interface ResolveGitHubTokenOptions {
+interface ResolveGitHubTokenOptions {
     repoInfo: GitHubRepoInfo;
     tokenManager: ITokenManager | null;
     context: string;

package/dist/shared/logger.d.ts

@@ -27,10 +27,10 @@ export interface ILogger {
     fileDiff(fileName: string, status: FileStatus, diffLines: string[]): void;
     diffSummary(newCount: number, modifiedCount: number, unchangedCount: number, deletedCount?: number): void;
     setTotal(total: number): void;
-    progress(current: number, repoName: string, message: string): void;
-    success(current: number, repoName: string, message: string): void;
-    skip(current: number, repoName: string, reason: string): void;
-    error(current: number, repoName: string, error: string): void;
+    progress(repoNumber: number, repoName: string, message: string): void;
+    success(repoNumber: number, repoName: string, message: string): void;
+    skip(repoNumber: number, repoName: string, reason: string): void;
+    error(repoNumber: number, repoName: string, error: string): void;
 }
 export declare class Logger implements ILogger {
     private readonly debugEnabled;
@@ -38,13 +38,13 @@ export declare class Logger implements ILogger {
     constructor(debugEnabled?: boolean);
     log(message: string): void;
     setTotal(total: number): void;
-    progress(current: number, repoName: string, message: string): void;
+    progress(repoNumber: number, repoName: string, message: string): void;
     info(message: string): void;
     warn(message: string): void;
     debug(message: string): void;
-    success(current: number, repoName: string, message: string): void;
-    skip(current: number, repoName: string, reason: string): void;
-    error(current: number, repoName: string, error: string): void;
+    success(repoNumber: number, repoName: string, message: string): void;
+    skip(repoNumber: number, repoName: string, reason: string): void;
+    error(repoNumber: number, repoName: string, error: string): void;
     /**
      * Display a file diff with status badge.
      * Used in dry-run mode to show what would change.

package/dist/shared/logger.js

@@ -17,8 +17,8 @@ export class Logger {
     setTotal(total) {
         this.stats.total = total;
     }
-    progress(current, repoName, message) {
-        console.log(chalk.blue(`[${current}/${this.stats.total}]`) +
+    progress(repoNumber, repoName, message) {
+        console.log(chalk.blue(`[${repoNumber}/${this.stats.total}]`) +
             ` ${repoName}: ${message}`);
     }
     info(message) {
@@ -32,19 +32,20 @@ export class Logger {
             console.log(chalk.dim(`    [debug] ${message}`));
         }
     }
-    success(current, repoName, message) {
+    success(repoNumber, repoName, message) {
         this.stats.succeeded++;
-        console.log(chalk.green(`[${current}/${this.stats.total}] ✓`) +
+        console.log(chalk.green(`[${repoNumber}/${this.stats.total}] ✓`) +
             ` ${repoName}: ${message}`);
     }
-    skip(current, repoName, reason) {
+    skip(repoNumber, repoName, reason) {
         this.stats.skipped++;
-        console.log(chalk.yellow(`[${current}/${this.stats.total}] ⊘`) +
+        console.log(chalk.yellow(`[${repoNumber}/${this.stats.total}] ⊘`) +
             ` ${repoName}: Skipped - ${reason}`);
     }
-    error(current, repoName, error) {
+    error(repoNumber, repoName, error) {
         this.stats.failed++;
-        console.log(chalk.red(`[${current}/${this.stats.total}] ✗`) + ` ${repoName}: ${error}`);
+        console.log(chalk.red(`[${repoNumber}/${this.stats.total}] ✗`) +
+            ` ${repoName}: ${error}`);
     }
     /**
      * Display a file diff with status badge.

package/dist/shared/repo-detector.js

@@ -1,5 +1,4 @@
 import { ValidationError } from "./errors.js";
-// Type guards
 export function isGitHubRepo(info) {
     return info.type === "github";
 }

package/dist/sync/branch-manager.js

@@ -1,8 +1,8 @@
-import { getPRStrategy } from "../vcs/index.js";
+import { createPRStrategy } from "../vcs/index.js";
 export class BranchManager {
     log;
     prStrategyFactory;
-    constructor(log, prStrategyFactory = getPRStrategy) {
+    constructor(log, prStrategyFactory = createPRStrategy) {
         this.log = log;
         this.prStrategyFactory = prStrategyFactory;
     }

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

@@ -1,10 +1,10 @@
-import { getCommitStrategy } from "../vcs/index.js";
+import { createCommitStrategy } from "../vcs/index.js";
 import { getRepoDisplayName } from "../shared/repo-detector.js";
 import { toErrorMessage } from "../shared/type-guards.js";
 export class CommitPushManager {
     log;
     commitStrategyFactory;
-    constructor(log, commitStrategyFactory = getCommitStrategy) {
+    constructor(log, commitStrategyFactory = createCommitStrategy) {
         this.log = log;
         this.commitStrategyFactory = commitStrategyFactory;
     }

package/dist/sync/diff-utils.d.ts

@@ -2,9 +2,6 @@ export type { FileStatus } from "../shared/file-status.js";
 export { formatStatusBadge } from "../shared/file-status.js";
 import type { FileStatus } from "../shared/file-status.js";
 export declare function getFileStatus(exists: boolean, changed: boolean): FileStatus;
-/**
- * Format a single diff line with appropriate color.
- */
 export declare function formatDiffLine(line: string): string;
 /**
  * Check if a file is likely binary based on its extension.
@@ -30,11 +27,5 @@ export interface DiffStats {
     unchangedCount: number;
     deletedCount: number;
 }
-/**
- * Create an empty diff stats object.
- */
 export declare function createDiffStats(): DiffStats;
-/**
- * Increment the appropriate counter in diff stats.
- */
 export declare function incrementDiffStats(stats: DiffStats, status: FileStatus): void;

package/dist/sync/diff-utils.js

@@ -5,9 +5,6 @@ export function getFileStatus(exists, changed) {
         return "NEW";
     return changed ? "MODIFIED" : "UNCHANGED";
 }
-/**
- * Format a single diff line with appropriate color.
- */
 export function formatDiffLine(line) {
     if (line.startsWith("+"))
         return chalk.green(line);
@@ -261,15 +258,9 @@ function groupIntoHunks(ops, oldLines, newLines, contextLines) {
     }
     return hunks;
 }
-/**
- * Create an empty diff stats object.
- */
 export function createDiffStats() {
     return { newCount: 0, modifiedCount: 0, unchangedCount: 0, deletedCount: 0 };
 }
-/**
- * Increment the appropriate counter in diff stats.
- */
 export function incrementDiffStats(stats, status) {
     switch (status) {
         case "NEW":

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

@@ -22,7 +22,7 @@ export class FileSyncOrchestrator {
             hasAppCredentials: options.hasAppCredentials,
         }, { gitOps: session.gitOps, log: this.log });
         const filesWithDeleteOrphaned = new Map(repoConfig.files.map((f) => [f.fileName, f.deleteOrphaned]));
-        const { manifest: newManifest, existingManifest, filesToDelete, } = this.manifestManager.processOrphans(workDir, configId, filesWithDeleteOrphaned);
+        const { manifest: newManifest, existingManifest, filesToDelete, } = this.manifestManager.detectOrphans(workDir, configId, filesWithDeleteOrphaned);
         this.manifestManager.deleteOrphans(filesToDelete, { dryRun: dryRun, noDelete: noDelete }, { gitOps: session.gitOps, log: this.log, fileChanges });
         // Save manifest (may add to fileChanges)
         this.manifestManager.saveUpdatedManifest(workDir, newManifest, existingManifest, dryRun, fileChanges);

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

@@ -1,4 +1,4 @@
-import type { RepoConfig } from "../config/types.js";
+import type { RepoConfig } from "../config/index.js";
 import type { RepoInfo } from "../shared/repo-detector.js";
 import type { IWorkStrategy, WorkResult, SessionContext, ProcessorOptions, IFileSyncOrchestrator } from "./types.js";
 /**