@aspruyt/xfg 6.0.0 → 6.0.2

package/dist/cli/sync-command.js

@@ -2,12 +2,12 @@ import { resolve, join } from "node:path";
 import { existsSync } from "node:fs";
 import { loadRawConfig, normalizeConfig, validateForSync, } from "../config/index.js";
 import { ValidationError, SyncError } from "../shared/errors.js";
-import { parseGitUrl, getRepoDisplayName, isGitHubRepo, } from "../shared/repo-detector.js";
+import { parseGitUrl, getRepoDisplayName, isGitHubRepo, } from "../repo/index.js";
 import { sanitizeBranchName, validateBranchName } from "./branch-utils.js";
 import { createTokenManager } from "../vcs/index.js";
 import { RepositoryProcessor } from "../sync/index.js";
 import { RulesetProcessor, RepoSettingsProcessor, LabelsProcessor, CodeScanningProcessor, GitHubRulesetStrategy, GitHubRepoSettingsStrategy, GitHubLabelsStrategy, GitHubCodeScanningStrategy, } from "../settings/index.js";
-import { GitHubRepoMetadataProvider } from "../shared/repo-metadata-provider.js";
+import { GitHubRepoMetadataProvider } from "../repo/index.js";
 import { ShellCommandExecutor } from "../shared/command-executor.js";
 import { Logger } from "../shared/logger.js";
 import { generateWorkspaceName } from "../shared/workspace-utils.js";
@@ -44,7 +44,7 @@ import { buildSyncReport } from "./sync-report-builder.js";
 import { formatSyncReportCLI } from "../output/sync-report.js";
 import { buildLifecycleReport } from "./lifecycle-report-builder.js";
 import { formatLifecycleReportCLI, hasLifecycleChanges, } from "../output/lifecycle-report.js";
-import { writeUnifiedSummary } from "../output/unified-summary.js";
+import { writeUnifiedSummary } from "./unified-summary.js";
 import { toErrorMessage } from "../shared/type-guards.js";
 import { resolveGitHubToken } from "../shared/gh-api-utils.js";
 import { RepoLifecycleManager, runLifecycleCheck, } from "../lifecycle/index.js";
@@ -116,7 +116,8 @@ async function runAndStoreResult(factory, repoConfig, repoInfo, opts, repoName,
     return result;
 }
 function buildSettingsDescriptors(ctx) {
-    const { repoConfig, repoInfo, options, token, repoName, settingsCollector, rulesetProcessorFactory, repoSettingsProcessorFactory, labelsProcessorFactory, codeScanningProcessorFactory, } = ctx;
+    const { repoConfig, repoInfo, options, token, repoName, settingsCollector } = ctx;
+    const { factories } = ctx;
     const sharedOpts = {
         dryRun: options.dryRun,
         noDelete: options.noDelete,
@@ -126,28 +127,28 @@ function buildSettingsDescriptors(ctx) {
         {
             key: "rulesets",
             label: "Rulesets",
-            run: () => runAndStoreResult(rulesetProcessorFactory, repoConfig, repoInfo, sharedOpts, repoName, settingsCollector, (e, r) => {
+            run: () => runAndStoreResult(factories.rulesets, repoConfig, repoInfo, sharedOpts, repoName, settingsCollector, (e, r) => {
                 e.rulesetResult = r;
             }),
         },
         {
             key: "labels",
             label: "Labels",
-            run: () => runAndStoreResult(labelsProcessorFactory, repoConfig, repoInfo, sharedOpts, repoName, settingsCollector, (e, r) => {
+            run: () => runAndStoreResult(factories.labels, repoConfig, repoInfo, sharedOpts, repoName, settingsCollector, (e, r) => {
                 e.labelsResult = r;
             }),
         },
         {
             key: "repo",
             label: "Repo Settings",
-            run: () => runAndStoreResult(repoSettingsProcessorFactory, repoConfig, repoInfo, { dryRun: options.dryRun, token }, repoName, settingsCollector, (e, r) => {
+            run: () => runAndStoreResult(factories.repo, repoConfig, repoInfo, { dryRun: options.dryRun, token }, repoName, settingsCollector, (e, r) => {
                 e.settingsResult = r;
             }),
         },
         {
             key: "codeScanning",
             label: "Code Scanning",
-            run: () => runAndStoreResult(codeScanningProcessorFactory, repoConfig, repoInfo, sharedOpts, repoName, settingsCollector, (e, r) => {
+            run: () => runAndStoreResult(factories.codeScanning, repoConfig, repoInfo, sharedOpts, repoName, settingsCollector, (e, r) => {
                 e.codeScanningResult = r;
             }),
         },
@@ -211,6 +212,14 @@ function displayReports(reportResults, lifecycleReportInputs, settingsCollector,
         summaryPath: process.env.GITHUB_STEP_SUMMARY,
     });
 }
+function pushFailure(results, repoName, error) {
+    results.push({
+        repoName,
+        success: false,
+        fileChanges: [],
+        error: toErrorMessage(error),
+    });
+}
 /**
  * Process a single repository: resolve URL, run lifecycle check, sync files, apply settings.
  * Pushes results into ctx.reportResults, ctx.lifecycleReportInputs, and ctx.settingsCollector.
@@ -239,12 +248,7 @@ async function processSingleRepo(repoConfig, index, ctx) {
     }
     catch (error) {
         getLogger().error(repoNumber, repoConfig.git, toErrorMessage(error));
-        ctx.reportResults.push({
-            repoName: repoConfig.git,
-            success: false,
-            fileChanges: [],
-            error: toErrorMessage(error),
-        });
+        pushFailure(ctx.reportResults, repoConfig.git, error);
         return;
     }
     const repoName = getRepoDisplayName(repoInfo);
@@ -280,10 +284,7 @@ async function processSingleRepo(repoConfig, index, ctx) {
         options,
         token: repoToken,
         settingsCollector: ctx.settingsCollector,
-        rulesetProcessorFactory: ctx.rulesetProcessorFactory,
-        repoSettingsProcessorFactory: ctx.repoSettingsProcessorFactory,
-        labelsProcessorFactory: ctx.labelsProcessorFactory,
-        codeScanningProcessorFactory: ctx.codeScanningProcessorFactory,
+        factories: ctx.factories,
     });
 }
 /**
@@ -330,12 +331,7 @@ async function runLifecyclePhase(repo, ctx) {
     }
     catch (error) {
         getLogger().error(repoNumber, repo.repoName, `Lifecycle error: ${toErrorMessage(error)}`);
-        ctx.reportResults.push({
-            repoName: repo.repoName,
-            success: false,
-            fileChanges: [],
-            error: toErrorMessage(error),
-        });
+        pushFailure(ctx.reportResults, repo.repoName, error);
         return true;
     }
 }
@@ -383,19 +379,24 @@ async function runFileSyncPhase(repo, ctx) {
     }
     catch (error) {
         getLogger().error(repoNumber, repo.repoName, toErrorMessage(error));
-        ctx.reportResults.push({
-            repoName: repo.repoName,
-            success: false,
-            fileChanges: [],
-            error: toErrorMessage(error),
-        });
+        pushFailure(ctx.reportResults, repo.repoName, error);
     }
 }
 export async function runSync(options, deps = {}) {
     // Reset module-level singletons to ensure fresh state per invocation
     _defaultExecutor = undefined;
     _logger = undefined;
-    const { lifecycleManager, rulesetProcessorFactory = createDefaultRulesetProcessorFactory(), repoSettingsProcessorFactory = createDefaultRepoSettingsProcessorFactory(), labelsProcessorFactory = createDefaultLabelsProcessorFactory(), codeScanningProcessorFactory = createDefaultCodeScanningProcessorFactory(), } = deps;
+    const { lifecycleManager, settingsProcessorFactories } = deps;
+    const factories = {
+        rulesets: settingsProcessorFactories?.rulesets ??
+            createDefaultRulesetProcessorFactory(),
+        labels: settingsProcessorFactories?.labels ??
+            createDefaultLabelsProcessorFactory(),
+        repo: settingsProcessorFactories?.repo ??
+            createDefaultRepoSettingsProcessorFactory(),
+        codeScanning: settingsProcessorFactories?.codeScanning ??
+            createDefaultCodeScanningProcessorFactory(),
+    };
     const configPath = resolve(options.config);
     if (!existsSync(configPath)) {
         throw new ValidationError(`Config path not found: ${configPath}`);
@@ -443,10 +444,7 @@ export async function runSync(options, deps = {}) {
         reportResults: [],
         lifecycleReportInputs: [],
         settingsCollector: new ResultsCollector(),
-        rulesetProcessorFactory,
-        repoSettingsProcessorFactory,
-        labelsProcessorFactory,
-        codeScanningProcessorFactory,
+        factories,
     };
     for (let i = 0; i < config.repos.length; i++) {
         await processSingleRepo(config.repos[i], i, ctx);

package/dist/cli/types.d.ts

@@ -1,8 +1,8 @@
 import type { MergeMode, MergeStrategy, RepoConfig } from "../config/index.js";
 import type { IRepoLifecycleManager } from "../lifecycle/index.js";
 import type { IRepositoryProcessor } from "../sync/index.js";
-import type { ISettingsProcessor, IRulesetProcessor, IRepoSettingsProcessor, ILabelsProcessor, ICodeScanningProcessor, BaseProcessorResult } from "../settings/index.js";
-import type { RepoInfo } from "../shared/repo-detector.js";
+import type { ISettingsProcessor, IRulesetProcessor, IRepoSettingsProcessor, ILabelsProcessor, ICodeScanningProcessor, BaseProcessorResult, ActiveAction } from "../settings/index.js";
+import type { RepoInfo } from "../repo/index.js";
 import type { ResultsCollector } from "./results-collector.js";
 export type ProcessorFactory = () => IRepositoryProcessor;
 export type SettingsProcessorFactory<T extends ISettingsProcessor> = () => T;
@@ -10,16 +10,20 @@ export type RulesetProcessorFactory = SettingsProcessorFactory<IRulesetProcessor
 export type RepoSettingsProcessorFactory = SettingsProcessorFactory<IRepoSettingsProcessor>;
 export type LabelsProcessorFactory = SettingsProcessorFactory<ILabelsProcessor>;
 export type CodeScanningProcessorFactory = SettingsProcessorFactory<ICodeScanningProcessor>;
+export type SettingsKind = "rulesets" | "labels" | "repo" | "codeScanning";
+export interface SettingsProcessorFactories {
+    rulesets: RulesetProcessorFactory;
+    labels: LabelsProcessorFactory;
+    repo: RepoSettingsProcessorFactory;
+    codeScanning: CodeScanningProcessorFactory;
+}
 /**
  * Dependencies for the sync command (dependency injection).
  */
 export interface SyncDependencies {
     processorFactory?: ProcessorFactory;
     lifecycleManager?: IRepoLifecycleManager;
-    rulesetProcessorFactory?: RulesetProcessorFactory;
-    repoSettingsProcessorFactory?: RepoSettingsProcessorFactory;
-    labelsProcessorFactory?: LabelsProcessorFactory;
-    codeScanningProcessorFactory?: CodeScanningProcessorFactory;
+    settingsProcessorFactories?: Partial<SettingsProcessorFactories>;
 }
 export interface SharedOptions {
     config: string;
@@ -39,7 +43,7 @@ export interface SyncResultEntry {
     success: boolean;
     fileChanges: Array<{
         path: string;
-        action: "create" | "update" | "delete";
+        action: ActiveAction;
         diffLines?: string[];
     }>;
     prUrl?: string;
@@ -64,8 +68,5 @@ export interface ApplyRepoSettingsContext {
     options: SyncOptions;
     token: string | undefined;
     settingsCollector: ResultsCollector;
-    rulesetProcessorFactory: NonNullable<SyncDependencies["rulesetProcessorFactory"]>;
-    repoSettingsProcessorFactory: NonNullable<SyncDependencies["repoSettingsProcessorFactory"]>;
-    labelsProcessorFactory: NonNullable<SyncDependencies["labelsProcessorFactory"]>;
-    codeScanningProcessorFactory: NonNullable<SyncDependencies["codeScanningProcessorFactory"]>;
+    factories: SettingsProcessorFactories;
 }

package/dist/{output → cli}/unified-summary.d.ts

@@ -1,6 +1,6 @@
-import type { LifecycleReport } from "./lifecycle-report.js";
-import type { SyncReport } from "./types.js";
-import type { SettingsReport } from "./settings-report.js";
+import type { LifecycleReport } from "../output/lifecycle-report.js";
+import type { SyncReport } from "../output/types.js";
+import type { SettingsReport } from "../output/settings-report.js";
 interface UnifiedSummaryInput {
     lifecycle?: LifecycleReport;
     sync?: SyncReport;

package/dist/{output → cli}/unified-summary.js

@@ -1,7 +1,7 @@
-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";
+import { hasLifecycleChanges } from "../output/lifecycle-report.js";
+import { writeGitHubStepSummary } from "../output/github-summary.js";
+import { renderSyncLines } from "../output/sync-report.js";
+import { renderRepoSettingsDiffLines, formatCountEntry, } from "../output/settings-report.js";
 // =============================================================================
 // Helpers
 // =============================================================================

package/dist/config/file-reference-resolver.js

@@ -83,6 +83,25 @@ function resolveContentValue(value, configDir) {
     // Otherwise return as-is (objects, arrays, plain strings)
     return value;
 }
+function resolveContentInFilesMap(filesMap, configDir) {
+    if (!filesMap) {
+        return;
+    }
+    for (const [fileName, fileConfig] of Object.entries(filesMap)) {
+        if (fileConfig === false) {
+            continue;
+        }
+        if (fileConfig &&
+            typeof fileConfig === "object" &&
+            "content" in fileConfig) {
+            const typed = fileConfig;
+            const resolved = resolveContentValue(typed.content, configDir);
+            if (resolved !== undefined) {
+                filesMap[fileName] = { ...fileConfig, content: resolved };
+            }
+        }
+    }
+}
 /**
  * Resolve all file references in a raw config.
  * Walks through files at root level and per-repo level.
@@ -100,74 +119,23 @@ export function resolveFileReferencesInConfig(raw, options) {
         result.prTemplate = resolved;
     }
     // Resolve root-level file content
-    if (result.files) {
-        for (const [fileName, fileConfig] of Object.entries(result.files)) {
-            if (fileConfig &&
-                typeof fileConfig === "object" &&
-                "content" in fileConfig) {
-                const resolved = resolveContentValue(fileConfig.content, configDir);
-                if (resolved !== undefined) {
-                    result.files[fileName] = { ...fileConfig, content: resolved };
-                }
-            }
-        }
-    }
+    resolveContentInFilesMap(result.files, configDir);
     // Resolve group-level file content
     if (result.groups) {
-        for (const [groupName, group] of Object.entries(result.groups)) {
-            if (group.files) {
-                for (const [fileName, fileConfig] of Object.entries(group.files)) {
-                    if (fileConfig &&
-                        typeof fileConfig === "object" &&
-                        "content" in fileConfig) {
-                        const resolved = resolveContentValue(fileConfig.content, configDir);
-                        if (resolved !== undefined) {
-                            result.groups[groupName].files[fileName] = {
-                                ...fileConfig,
-                                content: resolved,
-                            };
-                        }
-                    }
-                }
-            }
+        for (const group of Object.values(result.groups)) {
+            resolveContentInFilesMap(group.files, configDir);
         }
     }
     // Resolve conditional group file content
     if (result.conditionalGroups) {
         for (const cg of result.conditionalGroups) {
-            if (cg.files) {
-                for (const [fileName, fileConfig] of Object.entries(cg.files)) {
-                    if (fileConfig &&
-                        typeof fileConfig === "object" &&
-                        "content" in fileConfig) {
-                        const resolved = resolveContentValue(fileConfig.content, configDir);
-                        if (resolved !== undefined) {
-                            cg.files[fileName] = { ...fileConfig, content: resolved };
-                        }
-                    }
-                }
-            }
+            resolveContentInFilesMap(cg.files, configDir);
         }
     }
     // Resolve per-repo file content
     if (result.repos) {
         for (const repo of result.repos) {
-            if (repo.files) {
-                for (const [fileName, fileOverride] of Object.entries(repo.files)) {
-                    // Skip false (exclusion) entries
-                    if (fileOverride === false) {
-                        continue;
-                    }
-                    if (fileOverride &&
-                        typeof fileOverride === "object" &&
-                        "content" in fileOverride) {
-                        const resolved = resolveContentValue(fileOverride.content, configDir);
-                        if (resolved !== undefined) {
-                            repo.files[fileName] = { ...fileOverride, content: resolved };
-                        }
-                    }
-                }
-            }
+            resolveContentInFilesMap(repo.files, configDir);
         }
     }
     return result;

package/dist/config/normalizer.js

@@ -294,6 +294,28 @@ function mergeGroupPROptions(rootPR, groupNames, groupDefs) {
     }
     return accumulated;
 }
+/**
+ * Merges a named-entry map (e.g. rulesets, labels) where overlay entries
+ * extend or replace base entries. `inherit: false` in the overlay discards
+ * the base; `false` values mark explicit opt-outs. The merge callback runs
+ * when both base and overlay have an entry with the same name.
+ */
+function mergeNamedEntries(base, overlay, merge) {
+    const inherit = shouldInherit(overlay);
+    const result = inherit ? { ...(base ?? {}) } : {};
+    for (const [name, entry] of Object.entries(overlay)) {
+        if (name === "inherit")
+            continue;
+        if (entry === false) {
+            result[name] = false;
+        }
+        else if (typeof entry === "object" && entry !== null) {
+            const existing = result[name];
+            result[name] = merge(existing, entry);
+        }
+    }
+    return result;
+}
 /**
  * Merges two raw settings layers (root/group into accumulated).
  * Unlike mergeSettings(), this operates on raw types and returns raw types,
@@ -308,26 +330,9 @@ function mergeRawSettings(base, overlay) {
     const result = base ? structuredClone(base) : {};
     // Merge rulesets
     if (overlay.rulesets) {
-        const inheritRulesets = shouldInherit(overlay.rulesets);
-        if (!inheritRulesets) {
-            // Discard accumulated rulesets, start fresh with overlay's own
-            result.rulesets = {};
-        }
-        if (!result.rulesets)
-            result.rulesets = {};
-        for (const [name, ruleset] of Object.entries(overlay.rulesets)) {
-            if (name === "inherit")
-                continue;
-            if (ruleset === false) {
-                result.rulesets[name] = false;
-            }
-            else if (typeof ruleset === "object") {
-                const existing = result.rulesets[name];
-                result.rulesets[name] = existing
-                    ? mergeRuleset(existing, ruleset)
-                    : structuredClone(ruleset);
-            }
-        }
+        result.rulesets = mergeNamedEntries(result.rulesets, overlay.rulesets, (existing, entry) => existing && typeof existing === "object"
+            ? mergeRuleset(existing, entry)
+            : structuredClone(entry));
     }
     // Merge repo settings: overlay replaces base (shallow merge, same as mergeSettings)
     if (overlay.repo !== undefined) {
@@ -343,26 +348,10 @@ function mergeRawSettings(base, overlay) {
     }
     // Merge labels
     if (overlay.labels) {
-        const inheritLabels = shouldInherit(overlay.labels);
-        if (!inheritLabels) {
-            result.labels = {};
-        }
-        if (!result.labels)
-            result.labels = {};
-        for (const [name, label] of Object.entries(overlay.labels)) {
-            if (name === "inherit")
-                continue;
-            if (label === false) {
-                result.labels[name] = false;
-            }
-            else if (typeof label === "object") {
-                const existing = result.labels[name];
-                result.labels[name] = {
-                    ...(existing && typeof existing === "object" ? existing : {}),
-                    ...label,
-                };
-            }
-        }
+        result.labels = mergeNamedEntries(result.labels, overlay.labels, (existing, entry) => ({
+            ...(existing && typeof existing === "object" ? existing : {}),
+            ...entry,
+        }));
     }
     // Merge code scanning: overlay fully replaces base (same semantics as mergeSettings)
     if (overlay.codeScanning !== undefined) {