@aspruyt/xfg 3.5.0 → 3.5.2

package/README.md

@@ -65,6 +65,11 @@ files:
       tabWidth: 2
 
 settings:
+  repo:
+    allowSquashMerge: true
+    deleteBranchOnMerge: true
+    vulnerabilityAlerts: true
+
   rulesets:
     main-protection:
       target: branch
@@ -84,7 +89,7 @@ repos:
       - git@github.com:your-org/backend-api.git
 ```
 
-**Result:** PRs are created with `.prettierrc.json` files, and repos get branch protection rules.
+**Result:** PRs are created with `.prettierrc.json` files, and repos get standardized merge options, security settings, and branch protection rules.
 
 ## Documentation
 

package/dist/config.d.ts

@@ -210,6 +210,11 @@ export interface Ruleset {
     /** Rules to enforce */
     rules?: RulesetRule[];
 }
+/**
+ * Set of snake_case field names that are comparable between config and API.
+ * Used as an allowlist — any API response field not in this set is ignored.
+ */
+export declare const RULESET_COMPARABLE_FIELDS: Set<string>;
 /** Squash merge commit title format */
 export type SquashMergeCommitTitle = "PR_TITLE" | "COMMIT_OR_PR_TITLE";
 /** Squash merge commit message format */

package/dist/config.js

@@ -7,6 +7,22 @@ export { normalizeConfigInternal as normalizeConfig };
 import { resolveFileReferencesInConfig } from "./file-reference-resolver.js";
 // Re-export formatter functions for backwards compatibility
 export { convertContentToString } from "./config-formatter.js";
+/**
+ * Maps Ruleset config keys (camelCase) to GitHub API keys (snake_case).
+ * TypeScript enforces this stays in sync with the Ruleset interface.
+ */
+const RULESET_FIELD_MAP = {
+    target: "target",
+    enforcement: "enforcement",
+    bypassActors: "bypass_actors",
+    conditions: "conditions",
+    rules: "rules",
+};
+/**
+ * Set of snake_case field names that are comparable between config and API.
+ * Used as an allowlist — any API response field not in this set is ignored.
+ */
+export const RULESET_COMPARABLE_FIELDS = new Set(Object.values(RULESET_FIELD_MAP));
 // =============================================================================
 // Public API
 // =============================================================================

package/dist/github-summary.d.ts

@@ -5,6 +5,20 @@ export interface FileChanges {
     deleted: number;
     unchanged: number;
 }
+export interface RulesetPlanDetail {
+    name: string;
+    action: "create" | "update" | "delete" | "unchanged";
+    propertyCount?: number;
+    propertyChanges?: {
+        added: number;
+        changed: number;
+        removed: number;
+    };
+}
+export interface RepoSettingsPlanDetail {
+    property: string;
+    action: "add" | "change";
+}
 export interface RepoResult {
     repoName: string;
     status: "succeeded" | "skipped" | "failed";
@@ -12,8 +26,12 @@ export interface RepoResult {
     prUrl?: string;
     mergeOutcome?: MergeOutcome;
     fileChanges?: FileChanges;
+    rulesetPlanDetails?: RulesetPlanDetail[];
+    repoSettingsPlanDetails?: RepoSettingsPlanDetail[];
 }
 export interface SummaryData {
+    title: string;
+    dryRun?: boolean;
     total: number;
     succeeded: number;
     skipped: number;

package/dist/github-summary.js

@@ -8,23 +8,38 @@ function formatFileChanges(changes) {
         return "-";
     return `+${changes.added} ~${changes.modified} -${changes.deleted}`;
 }
-function formatStatus(result) {
+function formatChangesColumn(result) {
+    if (result.fileChanges) {
+        return formatFileChanges(result.fileChanges);
+    }
+    // For settings results, derive changes from plan details
+    const parts = [];
+    if (result.rulesetPlanDetails && result.rulesetPlanDetails.length > 0) {
+        parts.push(formatRulesetPlanSummary(result.rulesetPlanDetails));
+    }
+    if (result.repoSettingsPlanDetails &&
+        result.repoSettingsPlanDetails.length > 0) {
+        parts.push(formatSettingsPlanSummary(result.repoSettingsPlanDetails));
+    }
+    return parts.length > 0 ? parts.join("; ") : "-";
+}
+function formatStatus(result, dryRun) {
     if (result.status === "skipped")
-        return "⏭️ Skipped";
+        return dryRun ? "⏭️ Would Skip" : "⏭️ Skipped";
     if (result.status === "failed")
-        return "❌ Failed";
+        return dryRun ? "❌ Would Fail" : "❌ Failed";
     // Succeeded - format based on merge outcome
     switch (result.mergeOutcome) {
         case "manual":
-            return "✅ Open";
+            return dryRun ? "✅ Would Open" : "✅ Open";
         case "auto":
-            return "✅ Auto-merge";
+            return dryRun ? "✅ Would Auto-merge" : "✅ Auto-merge";
         case "force":
-            return "✅ Merged";
+            return dryRun ? "✅ Would Merge" : "✅ Merged";
         case "direct":
-            return "✅ Pushed";
+            return dryRun ? "✅ Would Push" : "✅ Pushed";
         default:
-            return "✅ Succeeded";
+            return dryRun ? "✅ Would Succeed" : "✅ Succeeded";
     }
 }
 function formatResult(result) {
@@ -39,17 +54,83 @@ function formatResult(result) {
     }
     return escapeMarkdown(result.message);
 }
+function formatRulesetAction(action) {
+    switch (action) {
+        case "create":
+            return "+ Create";
+        case "update":
+            return "~ Update";
+        case "delete":
+            return "- Delete";
+        case "unchanged":
+            return "= Unchanged";
+        default:
+            return action;
+    }
+}
+function formatRulesetProperties(detail) {
+    if (detail.propertyChanges) {
+        return `+${detail.propertyChanges.added} ~${detail.propertyChanges.changed} -${detail.propertyChanges.removed}`;
+    }
+    if (detail.propertyCount !== undefined) {
+        return `${detail.propertyCount} properties`;
+    }
+    return "-";
+}
+function formatRulesetPlanSummary(details) {
+    const creates = details.filter((d) => d.action === "create").length;
+    const updates = details.filter((d) => d.action === "update").length;
+    const deletes = details.filter((d) => d.action === "delete").length;
+    const parts = [];
+    if (creates > 0)
+        parts.push(`${creates} to create`);
+    if (updates > 0)
+        parts.push(`${updates} to update`);
+    if (deletes > 0)
+        parts.push(`${deletes} to delete`);
+    return parts.join(", ") || "no changes";
+}
+function formatSettingsAction(action) {
+    switch (action) {
+        case "add":
+            return "+ Add";
+        case "change":
+            return "~ Change";
+        default:
+            return action;
+    }
+}
+function formatSettingsPlanSummary(details) {
+    const adds = details.filter((d) => d.action === "add").length;
+    const changes = details.filter((d) => d.action === "change").length;
+    const parts = [];
+    if (adds > 0)
+        parts.push(`${adds} to add`);
+    if (changes > 0)
+        parts.push(`${changes} to change`);
+    return parts.join(", ") || "no changes";
+}
 export function formatSummary(data) {
     const lines = [];
     // Header
-    lines.push("## Config Sync Summary");
+    const titleSuffix = data.dryRun ? " (Dry Run)" : "";
+    lines.push(`## ${data.title}${titleSuffix}`);
     lines.push("");
+    // Dry-run warning banner
+    if (data.dryRun) {
+        lines.push("> [!WARNING]");
+        lines.push("> This was a dry run — no changes were applied");
+        lines.push("");
+    }
     // Stats table
+    const succeededLabel = data.dryRun ? "✅ Would Succeed" : "✅ Succeeded";
+    const skippedLabel = data.dryRun ? "⏭️ Would Skip" : "⏭️ Skipped";
+    const failedLabel = data.dryRun ? "❌ Would Fail" : "❌ Failed";
     lines.push("| Status | Count |");
     lines.push("|--------|-------|");
-    lines.push(`| ✅ Succeeded | ${data.succeeded} |`);
-    lines.push(`| ⏭️ Skipped | ${data.skipped} |`);
-    lines.push(`| ❌ Failed | ${data.failed} |`);
+    lines.push(`| ${succeededLabel} | ${data.succeeded} |`);
+    lines.push(`| ${skippedLabel} | ${data.skipped} |`);
+    lines.push(`| ${failedLabel} | ${data.failed} |`);
     lines.push(`| **Total** | **${data.total}** |`);
     // Repo details table (only if there are results)
     if (data.results.length > 0) {
@@ -61,11 +142,41 @@ export function formatSummary(data) {
         lines.push("|------------|--------|---------|--------|");
         for (const result of data.results) {
             const repo = result.repoName;
-            const status = formatStatus(result);
-            const changes = formatFileChanges(result.fileChanges);
+            const status = formatStatus(result, data.dryRun);
+            const changes = formatChangesColumn(result);
             const resultText = formatResult(result);
             lines.push(`| ${repo} | ${status} | ${changes} | ${resultText} |`);
         }
+        // Plan details nested sections
+        for (const result of data.results) {
+            if (result.rulesetPlanDetails && result.rulesetPlanDetails.length > 0) {
+                lines.push("");
+                lines.push("<details>");
+                lines.push(`<summary>${result.repoName} — Rulesets: ${formatRulesetPlanSummary(result.rulesetPlanDetails)}</summary>`);
+                lines.push("");
+                lines.push("| Ruleset | Action | Properties |");
+                lines.push("|---------|--------|------------|");
+                for (const detail of result.rulesetPlanDetails) {
+                    lines.push(`| ${detail.name} | ${formatRulesetAction(detail.action)} | ${formatRulesetProperties(detail)} |`);
+                }
+                lines.push("");
+                lines.push("</details>");
+            }
+            if (result.repoSettingsPlanDetails &&
+                result.repoSettingsPlanDetails.length > 0) {
+                lines.push("");
+                lines.push("<details>");
+                lines.push(`<summary>${result.repoName} — Repo Settings: ${formatSettingsPlanSummary(result.repoSettingsPlanDetails)}</summary>`);
+                lines.push("");
+                lines.push("| Setting | Action |");
+                lines.push("|---------|--------|");
+                for (const detail of result.repoSettingsPlanDetails) {
+                    lines.push(`| ${detail.property} | ${formatSettingsAction(detail.action)} |`);
+                }
+                lines.push("");
+                lines.push("</details>");
+            }
+        }
         lines.push("");
         lines.push("</details>");
     }
@@ -79,5 +190,5 @@ export function writeSummary(data) {
     if (!summaryPath)
         return;
     const markdown = formatSummary(data);
-    appendFileSync(summaryPath, markdown + "\n");
+    appendFileSync(summaryPath, "\n" + markdown + "\n");
 }

package/dist/index.js

@@ -174,6 +174,8 @@ export async function runSync(options, processorFactory = defaultProcessorFactor
     const skipped = results.filter((r) => r.status === "skipped").length;
     const failed = results.filter((r) => r.status === "failed").length;
     writeSummary({
+        title: "Config Sync Summary",
+        dryRun: options.dryRun,
         total: config.repos.length,
         succeeded,
         skipped,
@@ -324,6 +326,7 @@ export async function runSettings(options, processorFactory = defaultRulesetProc
                         ? "succeeded"
                         : "failed",
                 message: result.message,
+                rulesetPlanDetails: result.planOutput?.entries,
             });
         }
         catch (error) {
@@ -377,6 +380,21 @@ export async function runSettings(options, processorFactory = defaultRulesetProc
                     console.log(chalk.red(`  ✗ ${repoName}: ${result.message}`));
                     failCount++;
                 }
+                // Merge repo settings plan details into existing result or push new
+                if (!result.skipped) {
+                    const existing = results.find((r) => r.repoName === repoName);
+                    if (existing) {
+                        existing.repoSettingsPlanDetails = result.planOutput?.entries;
+                    }
+                    else {
+                        results.push({
+                            repoName,
+                            status: result.success ? "succeeded" : "failed",
+                            message: result.message,
+                            repoSettingsPlanDetails: result.planOutput?.entries,
+                        });
+                    }
+                }
             }
             catch (error) {
                 console.error(`  ✗ ${repoName}: ${error}`);
@@ -402,6 +420,8 @@ export async function runSettings(options, processorFactory = defaultRulesetProc
     console.log(`Completed: ${successCount} succeeded, ${skipCount} skipped, ${failCount} failed`);
     // Write GitHub Actions job summary if available
     writeSummary({
+        title: "Repository Settings Summary",
+        dryRun: options.dryRun,
         total: reposWithRulesets.length + reposWithRepoSettings.length,
         succeeded: successCount,
         skipped: skipCount,

package/dist/repo-settings-plan-formatter.d.ts

@@ -1,9 +1,14 @@
 import type { RepoSettingsChange } from "./repo-settings-diff.js";
+export interface RepoSettingsPlanEntry {
+    property: string;
+    action: "add" | "change";
+}
 export interface RepoSettingsPlanResult {
     lines: string[];
     adds: number;
     changes: number;
     warnings: string[];
+    entries: RepoSettingsPlanEntry[];
 }
 /**
  * Formats repo settings changes as Terraform-style plan output.

package/dist/repo-settings-plan-formatter.js

@@ -39,8 +39,9 @@ export function formatRepoSettingsPlan(changes) {
     const warnings = [];
     let adds = 0;
     let changesCount = 0;
+    const entries = [];
     if (changes.length === 0) {
-        return { lines, adds, changes: 0, warnings };
+        return { lines, adds, changes: 0, warnings, entries };
     }
     for (const change of changes) {
         const warning = getWarning(change);
@@ -50,13 +51,15 @@ export function formatRepoSettingsPlan(changes) {
         if (change.action === "add") {
             lines.push(chalk.green(`    + ${change.property}: ${formatValue(change.newValue)}`));
             adds++;
+            entries.push({ property: change.property, action: "add" });
         }
         else if (change.action === "change") {
             lines.push(chalk.yellow(`    ~ ${change.property}: ${formatValue(change.oldValue)} → ${formatValue(change.newValue)}`));
             changesCount++;
+            entries.push({ property: change.property, action: "change" });
         }
     }
-    return { lines, adds, changes: changesCount, warnings };
+    return { lines, adds, changes: changesCount, warnings, entries };
 }
 /**
  * Formats warnings for display.

package/dist/repo-settings-processor.js

@@ -66,6 +66,7 @@ export class RepoSettingsProcessor {
                 message: `Applied: ${planOutput.adds} added, ${planOutput.changes} changed`,
                 changes: { adds: planOutput.adds, changes: planOutput.changes },
                 warnings: planOutput.warnings,
+                planOutput,
             };
         }
         catch (error) {

package/dist/ruleset-diff.d.ts

@@ -1,4 +1,4 @@
-import type { Ruleset } from "./config.js";
+import { type Ruleset } from "./config.js";
 import type { GitHubRuleset } from "./strategies/github-ruleset-strategy.js";
 export type RulesetAction = "create" | "update" | "delete" | "unchanged";
 export interface RulesetChange {
@@ -8,6 +8,12 @@ export interface RulesetChange {
     current?: GitHubRuleset;
     desired?: Ruleset;
 }
+/**
+ * Projects `current` onto the shape of `desired`.
+ * Only keeps keys/structure present in `desired`, filtering out API noise.
+ * For arrays of objects, matches items by `type` field if present, else by index.
+ */
+export declare function projectToDesiredShape(current: unknown, desired: unknown): unknown;
 /**
  * Compares current rulesets (from GitHub) with desired rulesets (from config).
  *

package/dist/ruleset-diff.js

@@ -1,3 +1,4 @@
+import { RULESET_COMPARABLE_FIELDS } from "./config.js";
 // =============================================================================
 // Normalization (for comparison)
 // =============================================================================
@@ -28,18 +29,13 @@ function normalizeValue(value) {
     }
     return value;
 }
-/**
- * Fields to ignore when comparing rulesets (API-only metadata).
- * The "name" field is compared via map key, not content.
- */
-const IGNORE_FIELDS = new Set(["id", "name", "source_type", "source"]);
 /**
  * Normalizes a GitHub ruleset for comparison.
  */
 function normalizeGitHubRuleset(ruleset) {
     const normalized = {};
     for (const [key, value] of Object.entries(ruleset)) {
-        if (IGNORE_FIELDS.has(key) || value === undefined) {
+        if (!RULESET_COMPARABLE_FIELDS.has(key) || value === undefined) {
             continue;
         }
         normalized[key] = normalizeValue(value);
@@ -97,6 +93,84 @@ function deepEqual(a, b) {
     return false;
 }
 // =============================================================================
+// Desired-Side Projection
+// =============================================================================
+/**
+ * Projects `current` onto the shape of `desired`.
+ * Only keeps keys/structure present in `desired`, filtering out API noise.
+ * For arrays of objects, matches items by `type` field if present, else by index.
+ */
+export function projectToDesiredShape(current, desired) {
+    // Both must be same general type to project
+    if (desired === null || desired === undefined)
+        return desired;
+    if (current === null || current === undefined)
+        return current;
+    // Arrays
+    if (Array.isArray(desired) && Array.isArray(current)) {
+        return projectArrays(current, desired);
+    }
+    // Objects
+    if (isPlainObject(desired) && isPlainObject(current)) {
+        return projectObjects(current, desired);
+    }
+    // Scalars — return current as-is
+    return current;
+}
+function isPlainObject(val) {
+    return val !== null && typeof val === "object" && !Array.isArray(val);
+}
+function projectObjects(current, desired) {
+    const result = {};
+    for (const key of Object.keys(desired)) {
+        if (key in current) {
+            result[key] = projectToDesiredShape(current[key], desired[key]);
+        }
+        // If key not in current, skip — diff will handle it as an addition
+    }
+    return result;
+}
+function projectArrays(current, desired) {
+    // Primitive arrays — return current as-is
+    if (desired.length === 0 || !isPlainObject(desired[0])) {
+        return current;
+    }
+    // Arrays of objects — match by `type` field if available
+    const hasType = desired.every((item) => isPlainObject(item) && "type" in item);
+    if (hasType) {
+        return matchByType(current, desired);
+    }
+    // Fallback: match by index
+    return matchByIndex(current, desired);
+}
+function matchByType(current, desired) {
+    const currentByType = new Map();
+    for (const item of current) {
+        if (isPlainObject(item)) {
+            const type = item.type;
+            if (type)
+                currentByType.set(type, item);
+        }
+    }
+    const result = [];
+    for (const desiredItem of desired) {
+        const type = desiredItem.type;
+        const currentItem = currentByType.get(type);
+        if (currentItem) {
+            result.push(projectToDesiredShape(currentItem, desiredItem));
+        }
+        // If no match in current, skip — diff handles additions
+    }
+    return result;
+}
+function matchByIndex(current, desired) {
+    const result = [];
+    for (let i = 0; i < Math.min(current.length, desired.length); i++) {
+        result.push(projectToDesiredShape(current[i], desired[i]));
+    }
+    return result;
+}
+// =============================================================================
 // Diff Algorithm
 // =============================================================================
 /**
@@ -126,7 +200,8 @@ export function diffRulesets(current, desired, managedNames) {
             // Existing ruleset - check if changed
             const normalizedCurrent = normalizeGitHubRuleset(currentRuleset);
             const normalizedDesired = normalizeConfigRuleset(desiredRuleset);
-            if (deepEqual(normalizedCurrent, normalizedDesired)) {
+            const projectedCurrent = projectToDesiredShape(normalizedCurrent, normalizedDesired);
+            if (deepEqual(projectedCurrent, normalizedDesired)) {
                 changes.push({
                     action: "unchanged",
                     name,

package/dist/ruleset-plan-formatter.d.ts

@@ -1,4 +1,4 @@
-import type { RulesetChange } from "./ruleset-diff.js";
+import { type RulesetChange, type RulesetAction } from "./ruleset-diff.js";
 export type DiffAction = "add" | "change" | "remove";
 export interface PropertyDiff {
     path: string[];
@@ -6,12 +6,23 @@ export interface PropertyDiff {
     oldValue?: unknown;
     newValue?: unknown;
 }
+export interface RulesetPlanEntry {
+    name: string;
+    action: RulesetAction;
+    propertyCount?: number;
+    propertyChanges?: {
+        added: number;
+        changed: number;
+        removed: number;
+    };
+}
 export interface RulesetPlanResult {
     lines: string[];
     creates: number;
     updates: number;
     deletes: number;
     unchanged: number;
+    entries: RulesetPlanEntry[];
 }
 /**
  * Recursively compute property-level diffs between two objects.

package/dist/ruleset-plan-formatter.js

@@ -1,5 +1,7 @@
 // src/ruleset-plan-formatter.ts
 import chalk from "chalk";
+import { projectToDesiredShape, } from "./ruleset-diff.js";
+import { RULESET_COMPARABLE_FIELDS } from "./config.js";
 // =============================================================================
 // Property Diff Algorithm
 // =============================================================================
@@ -27,6 +29,13 @@ export function computePropertyDiffs(current, desired, parentPath = []) {
                 // 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,
@@ -67,6 +76,94 @@ function deepEqual(a, b) {
     }
     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;
+}
 /**
  * Build a tree structure from flat property diffs.
  */
@@ -101,7 +198,7 @@ function buildTree(diffs) {
     return root;
 }
 /**
- * Format a value for display.
+ * Format a value for inline display (scalars and simple arrays only).
  */
 function formatValue(val) {
     if (val === null)
@@ -111,16 +208,65 @@ function formatValue(val) {
     if (typeof val === "string")
         return `"${val}"`;
     if (Array.isArray(val)) {
-        if (val.length <= 3) {
+        if (val.every((v) => typeof v !== "object" || v === null)) {
             return `[${val.map(formatValue).join(", ")}]`;
         }
-        return `[${val.slice(0, 3).map(formatValue).join(", ")}, ... (${val.length - 3} more)]`;
+        // Arrays of objects are rendered by renderNestedValue
+        return `[${val.length} items]`;
     }
     if (typeof val === "object") {
-        return "{...}";
+        // Objects are rendered by renderNestedValue
+        return `{${Object.keys(val).length} properties}`;
     }
     return String(val);
 }
+/**
+ * Render a nested value (object or array) as indented tree lines.
+ */
+function renderNestedValue(val, action, indent) {
+    const lines = [];
+    const style = getActionStyle(action);
+    const indentStr = "    ".repeat(indent);
+    if (Array.isArray(val)) {
+        for (let i = 0; i < val.length; i++) {
+            const item = val[i];
+            if (isObject(item)) {
+                const obj = item;
+                const typeLabel = "type" in obj ? ` (${obj.type})` : "";
+                lines.push(style.color(`${indentStr}${style.symbol} [${i}]${typeLabel}:`));
+                lines.push(...renderNestedObject(obj, action, indent + 1));
+            }
+            else {
+                lines.push(style.color(`${indentStr}${style.symbol} [${i}]: ${formatValue(item)}`));
+            }
+        }
+    }
+    else if (isObject(val)) {
+        lines.push(...renderNestedObject(val, action, indent));
+    }
+    return lines;
+}
+function renderNestedObject(obj, action, indent) {
+    const lines = [];
+    const style = getActionStyle(action);
+    const indentStr = "    ".repeat(indent);
+    for (const [key, value] of Object.entries(obj)) {
+        if (value === null || value === undefined)
+            continue;
+        if (Array.isArray(value) && value.some((v) => isObject(v))) {
+            lines.push(style.color(`${indentStr}${style.symbol} ${key}:`));
+            lines.push(...renderNestedValue(value, action, indent + 1));
+        }
+        else if (isObject(value)) {
+            lines.push(style.color(`${indentStr}${style.symbol} ${key}:`));
+            lines.push(...renderNestedObject(value, action, indent + 1));
+        }
+        else {
+            lines.push(style.color(`${indentStr}${style.symbol} ${key}: ${formatValue(value)}`));
+        }
+    }
+    return lines;
+}
 /**
  * Get the symbol and color for an action.
  */
@@ -152,17 +298,43 @@ function renderTree(node, indent = 0) {
         }
         else {
             // Leaf node with value
-            let valuePart = "";
-            if (child.action === "change") {
-                valuePart = `: ${formatValue(child.oldValue)} → ${formatValue(child.newValue)}`;
+            const hasComplexNew = isObject(child.newValue) ||
+                (Array.isArray(child.newValue) &&
+                    child.newValue.some((v) => isObject(v)));
+            const hasComplexOld = isObject(child.oldValue) ||
+                (Array.isArray(child.oldValue) &&
+                    child.oldValue.some((v) => isObject(v)));
+            if (child.action === "add" && hasComplexNew) {
+                lines.push(style.color(`${indentStr}${style.symbol} ${child.name}:`));
+                lines.push(...renderNestedValue(child.newValue, child.action, indent + 1));
             }
-            else if (child.action === "add") {
-                valuePart = `: ${formatValue(child.newValue)}`;
+            else if (child.action === "remove" && hasComplexOld) {
+                lines.push(style.color(`${indentStr}${style.symbol} ${child.name} (removed):`));
+                lines.push(...renderNestedValue(child.oldValue, child.action, indent + 1));
             }
-            else if (child.action === "remove") {
-                valuePart = ` (was: ${formatValue(child.oldValue)})`;
+            else if (child.action === "change" &&
+                (hasComplexNew || hasComplexOld)) {
+                lines.push(style.color(`${indentStr}${style.symbol} ${child.name}:`));
+                if (hasComplexOld) {
+                    lines.push(...renderNestedValue(child.oldValue, "remove", indent + 1));
+                }
+                if (hasComplexNew) {
+                    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}`));
             }
-            lines.push(style.color(`${indentStr}${style.symbol} ${child.name}${valuePart}`));
         }
     }
     return lines;
@@ -186,12 +358,11 @@ export function formatPropertyTree(diffs) {
  */
 function normalizeForDiff(obj) {
     const result = {};
-    const ignoreFields = new Set(["id", "name", "source_type", "source"]);
     for (const [key, value] of Object.entries(obj)) {
-        if (ignoreFields.has(key) || value === undefined)
-            continue;
         // Convert camelCase to snake_case for consistency
         const snakeKey = key.replace(/([A-Z])/g, "_$1").toLowerCase();
+        if (!RULESET_COMPARABLE_FIELDS.has(snakeKey) || value === undefined)
+            continue;
         result[snakeKey] = normalizeNestedValue(value);
     }
     return result;
@@ -265,6 +436,7 @@ export function formatRulesetPlan(changes) {
     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");
@@ -282,6 +454,10 @@ export function formatRulesetPlan(changes) {
             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 });
             lines.push(""); // Blank line between rulesets
         }
     }
@@ -293,11 +469,23 @@ export function formatRulesetPlan(changes) {
             if (change.current && change.desired) {
                 const currentNorm = normalizeForDiff(change.current);
                 const desiredNorm = normalizeForDiff(change.desired);
-                const diffs = computePropertyDiffs(currentNorm, desiredNorm);
+                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 },
+                });
+            }
+            else {
+                entries.push({ name: change.name, action: "update" });
             }
             lines.push(""); // Blank line between rulesets
         }
@@ -307,8 +495,12 @@ export function formatRulesetPlan(changes) {
         lines.push(chalk.bold("  Delete:"));
         for (const change of deleteChanges) {
             lines.push(chalk.red(`    - ruleset "${change.name}"`));
+            entries.push({ name: change.name, action: "delete" });
         }
         lines.push(""); // Blank line after deletes
     }
-    return { lines, creates, updates, deletes, unchanged };
+    for (const change of unchangedChanges) {
+        entries.push({ name: change.name, action: "unchanged" });
+    }
+    return { lines, creates, updates, deletes, unchanged, entries };
 }

package/dist/ruleset-processor.js

@@ -58,10 +58,10 @@ export class RulesetProcessor {
                 delete: changes.filter((c) => c.action === "delete").length,
                 unchanged: changes.filter((c) => c.action === "unchanged").length,
             };
+            const planOutput = formatRulesetPlan(changes);
             // Dry run mode - report planned changes without applying
             if (dryRun) {
                 const summary = this.formatChangeSummary(changeCounts);
-                const planOutput = formatRulesetPlan(changes);
                 return {
                     success: true,
                     repoName,
@@ -106,6 +106,7 @@ export class RulesetProcessor {
                 repoName,
                 message: appliedCount > 0 ? `Applied: ${summary}` : "No changes needed",
                 changes: changeCounts,
+                planOutput,
                 manifestUpdate: this.computeManifestUpdate(desiredRulesets, deleteOrphaned),
             };
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aspruyt/xfg",
-  "version": "3.5.0",
+  "version": "3.5.2",
   "description": "CLI tool for repository-as-code",
   "type": "module",
   "main": "dist/index.js",