@aspruyt/xfg 3.7.7 → 3.8.0

package/dist/cli/settings-command.js

@@ -8,9 +8,8 @@ import { logger } from "../shared/logger.js";
 import { generateWorkspaceName } from "../shared/workspace-utils.js";
 import { buildErrorResult } from "../output/summary-utils.js";
 import { getManagedRulesets } from "../sync/manifest.js";
-import { printPlan } from "../output/plan-formatter.js";
-import { writePlanSummary } from "../output/plan-summary.js";
-import { rulesetResultToResources, repoSettingsResultToResources, } from "../settings/resource-converters.js";
+import { formatSettingsReportCLI, writeSettingsReportSummary, } from "../output/settings-report.js";
+import { buildSettingsReport } from "./settings-report-builder.js";
 import { defaultProcessorFactory, defaultRulesetProcessorFactory, defaultRepoSettingsProcessorFactory, } from "./types.js";
 /**
  * Run the settings command - manages GitHub Rulesets and repo settings.
@@ -51,7 +50,15 @@ export async function runSettings(options, processorFactory = defaultRulesetProc
     const processor = processorFactory();
     const repoProcessor = repoProcessorFactory();
     const results = [];
-    const plan = { resources: [], errors: [] };
+    const processingResults = [];
+    function getOrCreateResult(repoName) {
+        let result = processingResults.find((r) => r.repoName === repoName);
+        if (!result) {
+            result = { repoName };
+            processingResults.push(result);
+        }
+        return result;
+    }
     for (let i = 0; i < reposWithRulesets.length; i++) {
         const repoConfig = reposWithRulesets[i];
         let repoInfo;
@@ -63,26 +70,14 @@ export async function runSettings(options, processorFactory = defaultRulesetProc
         catch (error) {
             logger.error(i + 1, repoConfig.git, String(error));
             results.push(buildErrorResult(repoConfig.git, error));
-            plan.errors.push({
-                repo: repoConfig.git,
-                message: error instanceof Error ? error.message : String(error),
-            });
+            getOrCreateResult(repoConfig.git).error =
+                error instanceof Error ? error.message : String(error);
             continue;
         }
         const repoName = getRepoDisplayName(repoInfo);
         if (!isGitHubRepo(repoInfo)) {
             logger.skip(i + 1, repoName, "GitHub Rulesets only supported for GitHub repos");
-            if (repoConfig.settings?.rulesets) {
-                for (const rulesetName of Object.keys(repoConfig.settings.rulesets)) {
-                    plan.resources.push({
-                        type: "ruleset",
-                        repo: repoName,
-                        name: rulesetName,
-                        action: "skipped",
-                        skipReason: "GitHub Rulesets only supported for GitHub repos",
-                    });
-                }
-            }
+            // Skipped repos don't appear in the report
             continue;
         }
         const managedRulesets = getManagedRulesets(null, config.id);
@@ -135,15 +130,22 @@ export async function runSettings(options, processorFactory = defaultRulesetProc
                 message: result.message,
                 rulesetPlanDetails: result.planOutput?.entries,
             });
-            plan.resources.push(...rulesetResultToResources(repoName, result));
+            // Collect result for SettingsReport
+            if (!result.skipped) {
+                getOrCreateResult(repoName).rulesetResult = result;
+            }
         }
         catch (error) {
             logger.error(i + 1, repoName, String(error));
             results.push(buildErrorResult(repoName, error));
-            plan.errors.push({
-                repo: repoName,
-                message: error instanceof Error ? error.message : String(error),
-            });
+            const existingResult = getOrCreateResult(repoName);
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            if (existingResult.error) {
+                existingResult.error += `; ${errorMsg}`;
+            }
+            else {
+                existingResult.error = errorMsg;
+            }
         }
     }
     if (reposWithRepoSettings.length > 0) {
@@ -159,10 +161,8 @@ export async function runSettings(options, processorFactory = defaultRulesetProc
             }
             catch (error) {
                 console.error(`Failed to parse ${repoConfig.git}: ${error}`);
-                plan.errors.push({
-                    repo: repoConfig.git,
-                    message: error instanceof Error ? error.message : String(error),
-                });
+                getOrCreateResult(repoConfig.git).error =
+                    error instanceof Error ? error.message : String(error);
                 continue;
             }
             const repoName = getRepoDisplayName(repoInfo);
@@ -205,24 +205,33 @@ export async function runSettings(options, processorFactory = defaultRulesetProc
                         });
                     }
                 }
-                plan.resources.push(...repoSettingsResultToResources(repoName, result));
+                // Collect result for SettingsReport
+                if (!result.skipped) {
+                    getOrCreateResult(repoName).settingsResult = result;
+                }
             }
             catch (error) {
                 console.error(`  ✗ ${repoName}: ${error}`);
-                plan.errors.push({
-                    repo: repoName,
-                    message: error instanceof Error ? error.message : String(error),
-                });
+                const existingResult = getOrCreateResult(repoName);
+                const errorMsg = error instanceof Error ? error.message : String(error);
+                if (existingResult.error) {
+                    existingResult.error += `; ${errorMsg}`;
+                }
+                else {
+                    existingResult.error = errorMsg;
+                }
             }
         }
     }
     console.log("");
-    printPlan(plan);
-    writePlanSummary(plan, {
-        title: "Repository Settings Summary",
-        dryRun: options.dryRun ?? false,
-    });
-    if (plan.errors && plan.errors.length > 0) {
+    const report = buildSettingsReport(processingResults);
+    const lines = formatSettingsReportCLI(report);
+    for (const line of lines) {
+        console.log(line);
+    }
+    writeSettingsReportSummary(report, options.dryRun ?? false);
+    const hasErrors = report.repos.some((r) => r.error);
+    if (hasErrors) {
         process.exit(1);
     }
 }

package/dist/cli/settings-report-builder.d.ts

@@ -0,0 +1,19 @@
+import type { SettingsReport } from "../output/settings-report.js";
+import type { RepoSettingsPlanEntry } from "../settings/repo-settings/formatter.js";
+import type { RulesetPlanEntry } from "../settings/rulesets/formatter.js";
+interface ProcessorResults {
+    repoName: string;
+    settingsResult?: {
+        planOutput?: {
+            entries?: RepoSettingsPlanEntry[];
+        };
+    };
+    rulesetResult?: {
+        planOutput?: {
+            entries?: RulesetPlanEntry[];
+        };
+    };
+    error?: string;
+}
+export declare function buildSettingsReport(results: ProcessorResults[]): SettingsReport;
+export {};

package/dist/cli/settings-report-builder.js

@@ -0,0 +1,64 @@
+export function buildSettingsReport(results) {
+    const repos = [];
+    const totals = {
+        settings: { add: 0, change: 0 },
+        rulesets: { create: 0, update: 0, delete: 0 },
+    };
+    for (const result of results) {
+        const repoChanges = {
+            repoName: result.repoName,
+            settings: [],
+            rulesets: [],
+        };
+        // Convert settings processor output
+        if (result.settingsResult?.planOutput?.entries) {
+            for (const entry of result.settingsResult.planOutput.entries) {
+                // Skip settings where both values are undefined (no actual change)
+                if (entry.oldValue === undefined && entry.newValue === undefined) {
+                    continue;
+                }
+                const settingChange = {
+                    name: entry.property,
+                    action: entry.action,
+                    oldValue: entry.oldValue,
+                    newValue: entry.newValue,
+                };
+                repoChanges.settings.push(settingChange);
+                if (entry.action === "add") {
+                    totals.settings.add++;
+                }
+                else {
+                    totals.settings.change++;
+                }
+            }
+        }
+        // Convert ruleset processor output
+        if (result.rulesetResult?.planOutput?.entries) {
+            for (const entry of result.rulesetResult.planOutput.entries) {
+                if (entry.action === "unchanged")
+                    continue;
+                const rulesetChange = {
+                    name: entry.name,
+                    action: entry.action,
+                    propertyDiffs: entry.propertyDiffs,
+                    config: entry.config,
+                };
+                repoChanges.rulesets.push(rulesetChange);
+                if (entry.action === "create") {
+                    totals.rulesets.create++;
+                }
+                else if (entry.action === "update") {
+                    totals.rulesets.update++;
+                }
+                else if (entry.action === "delete") {
+                    totals.rulesets.delete++;
+                }
+            }
+        }
+        if (result.error) {
+            repoChanges.error = result.error;
+        }
+        repos.push(repoChanges);
+    }
+    return { repos, totals };
+}

package/dist/cli/sync-command.js

@@ -6,11 +6,9 @@ import { parseGitUrl, getRepoDisplayName } from "../shared/repo-detector.js";
 import { sanitizeBranchName, validateBranchName } from "../vcs/git-ops.js";
 import { logger } from "../shared/logger.js";
 import { generateWorkspaceName } from "../shared/workspace-utils.js";
-import { buildRepoResult, buildErrorResult } from "../output/summary-utils.js";
-import { printPlan } from "../output/plan-formatter.js";
-import { writePlanSummary } from "../output/plan-summary.js";
-import { syncResultToResources } from "../settings/resource-converters.js";
 import { defaultProcessorFactory } from "./types.js";
+import { buildSyncReport } from "./sync-report-builder.js";
+import { formatSyncReportCLI, writeSyncReportSummary, } from "../output/sync-report.js";
 /**
  * Get unique file names from all repos in the config
  */
@@ -44,6 +42,20 @@ function formatFileNames(fileNames) {
     }
     return `${fileNames.length} files`;
 }
+/**
+ * Determine merge outcome from processor result
+ */
+function determineMergeOutcome(result) {
+    if (!result.success)
+        return undefined;
+    if (!result.prUrl)
+        return "direct";
+    if (result.mergeResult?.merged)
+        return "force";
+    if (result.mergeResult?.autoMergeEnabled)
+        return "auto";
+    return "manual";
+}
 /**
  * Run the sync command - synchronizes files across repositories.
  */
@@ -80,8 +92,7 @@ export async function runSync(options, processorFactory = defaultProcessorFactor
     console.log(`Target files: ${formatFileNames(fileNames)}`);
     console.log(`Branch: ${branchName}\n`);
     const processor = processorFactory();
-    const results = [];
-    const plan = { resources: [], errors: [] };
+    const reportResults = [];
     for (let i = 0; i < config.repos.length; i++) {
         const repoConfig = config.repos[i];
         if (options.merge || options.mergeStrategy || options.deleteBranch) {
@@ -101,10 +112,11 @@ export async function runSync(options, processorFactory = defaultProcessorFactor
         }
         catch (error) {
             logger.error(current, repoConfig.git, String(error));
-            results.push(buildErrorResult(repoConfig.git, error));
-            plan.errors.push({
-                repo: repoConfig.git,
-                message: error instanceof Error ? error.message : String(error),
+            reportResults.push({
+                repoName: repoConfig.git,
+                success: false,
+                fileChanges: [],
+                error: error instanceof Error ? error.message : String(error),
             });
             continue;
         }
@@ -121,35 +133,48 @@ export async function runSync(options, processorFactory = defaultProcessorFactor
                 prTemplate: config.prTemplate,
                 noDelete: options.noDelete,
             });
-            const repoResult = buildRepoResult(repoName, repoConfig, result);
-            results.push(repoResult);
+            const mergeOutcome = determineMergeOutcome(result);
+            reportResults.push({
+                repoName,
+                success: result.success,
+                fileChanges: (result.fileChanges ?? []).map((f) => ({
+                    path: f.path,
+                    action: f.action,
+                })),
+                prUrl: result.prUrl,
+                mergeOutcome,
+                error: result.success ? undefined : result.message,
+            });
             if (result.skipped) {
                 logger.skip(current, repoName, result.message);
             }
             else if (result.success) {
-                logger.success(current, repoName, repoResult.message);
+                logger.success(current, repoName, result.message);
             }
             else {
                 logger.error(current, repoName, result.message);
             }
-            plan.resources.push(...syncResultToResources(repoName, repoConfig, result));
         }
         catch (error) {
             logger.error(current, repoName, String(error));
-            results.push(buildErrorResult(repoName, error));
-            plan.errors.push({
-                repo: repoName,
-                message: error instanceof Error ? error.message : String(error),
+            reportResults.push({
+                repoName,
+                success: false,
+                fileChanges: [],
+                error: error instanceof Error ? error.message : String(error),
             });
         }
     }
+    // Build and display report
+    const report = buildSyncReport(reportResults);
     console.log("");
-    printPlan(plan);
-    writePlanSummary(plan, {
-        title: "Config Sync Summary",
-        dryRun: options.dryRun ?? false,
-    });
-    if (plan.errors && plan.errors.length > 0) {
+    for (const line of formatSyncReportCLI(report)) {
+        console.log(line);
+    }
+    writeSyncReportSummary(report, options.dryRun ?? false);
+    // Exit with error if any failures
+    const hasErrors = reportResults.some((r) => r.error);
+    if (hasErrors) {
         process.exit(1);
     }
 }

package/dist/cli/sync-report-builder.d.ts

@@ -0,0 +1,15 @@
+import type { SyncReport } from "../output/sync-report.js";
+interface FileChangeInput {
+    path: string;
+    action: "create" | "update" | "delete";
+}
+interface SyncResultInput {
+    repoName: string;
+    success: boolean;
+    fileChanges: FileChangeInput[];
+    prUrl?: string;
+    mergeOutcome?: "manual" | "auto" | "force" | "direct";
+    error?: string;
+}
+export declare function buildSyncReport(results: SyncResultInput[]): SyncReport;
+export {};

package/dist/cli/sync-report-builder.js

@@ -0,0 +1,29 @@
+export function buildSyncReport(results) {
+    const repos = [];
+    const totals = {
+        files: { create: 0, update: 0, delete: 0 },
+    };
+    for (const result of results) {
+        const files = result.fileChanges.map((f) => ({
+            path: f.path,
+            action: f.action,
+        }));
+        // Count totals
+        for (const file of files) {
+            if (file.action === "create")
+                totals.files.create++;
+            else if (file.action === "update")
+                totals.files.update++;
+            else if (file.action === "delete")
+                totals.files.delete++;
+        }
+        repos.push({
+            repoName: result.repoName,
+            files,
+            prUrl: result.prUrl,
+            mergeOutcome: result.mergeOutcome,
+            error: result.error,
+        });
+    }
+    return { repos, totals };
+}

package/dist/output/index.d.ts

@@ -1,4 +1,4 @@
-export { formatResourceId, formatResourceLine, formatPlanSummary, formatPlan, printPlan, type ResourceType, type ResourceAction, type Resource, type ResourceDetails, type PropertyChange, type PlanCounts, type Plan, type RepoError, } from "./plan-formatter.js";
-export { formatPlanMarkdown, writePlanSummary, type PlanMarkdownOptions, } from "./plan-summary.js";
+export { formatSyncReportCLI, formatSyncReportMarkdown, writeSyncReportSummary, type SyncReport, type RepoFileChanges, type FileChange, } from "./sync-report.js";
+export { formatSettingsReportCLI, formatSettingsReportMarkdown, writeSettingsReportSummary, type SettingsReport, type RepoChanges, type RulesetChange, type SettingChange, } from "./settings-report.js";
 export { formatSummary, isGitHubActions, writeSummary, type MergeOutcome, type FileChanges, type RulesetPlanDetail, type RepoSettingsPlanDetail, type RepoResult, type SummaryData, } from "./github-summary.js";
 export { getMergeOutcome, toFileChanges, buildRepoResult, buildErrorResult, } from "./summary-utils.js";

package/dist/output/index.js

@@ -1,7 +1,7 @@
-// Plan formatting (console output with chalk)
-export { formatResourceId, formatResourceLine, formatPlanSummary, formatPlan, printPlan, } from "./plan-formatter.js";
-// Plan summary (markdown output for GitHub)
-export { formatPlanMarkdown, writePlanSummary, } from "./plan-summary.js";
+// Sync report (repo-grouped file changes)
+export { formatSyncReportCLI, formatSyncReportMarkdown, writeSyncReportSummary, } from "./sync-report.js";
+// Settings report (repo-grouped settings changes)
+export { formatSettingsReportCLI, formatSettingsReportMarkdown, writeSettingsReportSummary, } from "./settings-report.js";
 // GitHub Actions summary
 export { formatSummary, isGitHubActions, writeSummary, } from "./github-summary.js";
 // Summary utilities

package/dist/output/settings-report.d.ts

@@ -0,0 +1,37 @@
+import { type PropertyDiff } from "../settings/rulesets/formatter.js";
+import type { Ruleset } from "../config/index.js";
+export interface SettingsReport {
+    repos: RepoChanges[];
+    totals: {
+        settings: {
+            add: number;
+            change: number;
+        };
+        rulesets: {
+            create: number;
+            update: number;
+            delete: number;
+        };
+    };
+}
+export interface RepoChanges {
+    repoName: string;
+    settings: SettingChange[];
+    rulesets: RulesetChange[];
+    error?: string;
+}
+export interface SettingChange {
+    name: string;
+    action: "add" | "change";
+    oldValue?: unknown;
+    newValue: unknown;
+}
+export interface RulesetChange {
+    name: string;
+    action: "create" | "update" | "delete";
+    propertyDiffs?: PropertyDiff[];
+    config?: Ruleset;
+}
+export declare function formatSettingsReportCLI(report: SettingsReport): string[];
+export declare function formatSettingsReportMarkdown(report: SettingsReport, dryRun: boolean): string;
+export declare function writeSettingsReportSummary(report: SettingsReport, dryRun: boolean): void;