@aspruyt/xfg 3.7.6 → 3.8.0

package/dist/cli/index.d.ts

@@ -0,0 +1,6 @@
+export { runSync } from "./sync-command.js";
+export { runSettings } from "./settings-command.js";
+export { program } from "./program.js";
+export { type IRepositoryProcessor, type ProcessorFactory, type IRulesetProcessor, type RulesetProcessorFactory, type RepoSettingsProcessorFactory, type IRepoSettingsProcessor, defaultProcessorFactory, defaultRulesetProcessorFactory, defaultRepoSettingsProcessorFactory, } from "./types.js";
+export type { SyncOptions, SharedOptions } from "./sync-command.js";
+export type { SettingsOptions } from "./settings-command.js";

package/dist/cli/index.js

@@ -0,0 +1,9 @@
+// CLI command implementations
+export { runSync } from "./sync-command.js";
+export { runSettings } from "./settings-command.js";
+export { program } from "./program.js";
+// Export types - using 'export type' for type aliases, but interfaces need special handling
+// For ESM compatibility, re-export everything from types.js
+export { 
+// Runtime values
+defaultProcessorFactory, defaultRulesetProcessorFactory, defaultRepoSettingsProcessorFactory, } from "./types.js";

package/dist/cli/program.d.ts

@@ -0,0 +1,2 @@
+import { program } from "commander";
+export { program };

package/dist/cli/program.js

@@ -0,0 +1,70 @@
+import { program, Command } from "commander";
+import { dirname, join } from "node:path";
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { runSync } from "./sync-command.js";
+import { runSettings } from "./settings-command.js";
+// Get version from package.json
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const packageJson = JSON.parse(readFileSync(join(__dirname, "../..", "package.json"), "utf-8"));
+// =============================================================================
+// Shared CLI Options
+// =============================================================================
+/**
+ * Adds shared options to a command.
+ */
+function addSharedOptions(cmd) {
+    return cmd
+        .requiredOption("-c, --config <path>", "Path to YAML config file")
+        .option("-d, --dry-run", "Show what would be done without making changes")
+        .option("-w, --work-dir <path>", "Temporary directory for cloning", "./tmp")
+        .option("-r, --retries <number>", "Number of retries for network operations (0 to disable)", (v) => parseInt(v, 10), 3)
+        .option("--no-delete", "Skip deletion of orphaned resources even if deleteOrphaned is configured");
+}
+// =============================================================================
+// CLI Program
+// =============================================================================
+program
+    .name("xfg")
+    .description("Sync files and manage settings across repositories")
+    .version(packageJson.version);
+// Sync command (file synchronization)
+const syncCommand = new Command("sync")
+    .description("Sync configuration files across repositories")
+    .option("-b, --branch <name>", "Override the branch name (default: chore/sync-{filename} or chore/sync-config)")
+    .option("-m, --merge <mode>", "PR merge mode: manual, auto (default, merge when checks pass), force (bypass requirements), direct (push to default branch, no PR)", (value) => {
+    const valid = ["manual", "auto", "force", "direct"];
+    if (!valid.includes(value)) {
+        throw new Error(`Invalid merge mode: ${value}. Valid: ${valid.join(", ")}`);
+    }
+    return value;
+})
+    .option("--merge-strategy <strategy>", "Merge strategy: merge, squash (default), rebase", (value) => {
+    const valid = ["merge", "squash", "rebase"];
+    if (!valid.includes(value)) {
+        throw new Error(`Invalid merge strategy: ${value}. Valid: ${valid.join(", ")}`);
+    }
+    return value;
+})
+    .option("--delete-branch", "Delete source branch after merge")
+    .action((opts) => {
+    runSync(opts).catch((error) => {
+        console.error("Fatal error:", error);
+        process.exit(1);
+    });
+});
+addSharedOptions(syncCommand);
+program.addCommand(syncCommand);
+// Settings command (ruleset management)
+const settingsCommand = new Command("settings")
+    .description("Manage GitHub Rulesets for repositories")
+    .action((opts) => {
+    runSettings(opts).catch((error) => {
+        console.error("Fatal error:", error);
+        process.exit(1);
+    });
+});
+addSharedOptions(settingsCommand);
+program.addCommand(settingsCommand);
+export { program };

package/dist/cli/settings-command.d.ts

@@ -0,0 +1,10 @@
+import { SharedOptions } from "./sync-command.js";
+import { ProcessorFactory, RulesetProcessorFactory, RepoSettingsProcessorFactory } from "./types.js";
+/**
+ * Options for the settings command.
+ */
+export type SettingsOptions = SharedOptions;
+/**
+ * Run the settings command - manages GitHub Rulesets and repo settings.
+ */
+export declare function runSettings(options: SettingsOptions, processorFactory?: RulesetProcessorFactory, repoProcessorFactory?: ProcessorFactory, repoSettingsProcessorFactory?: RepoSettingsProcessorFactory): Promise<void>;

package/dist/cli/settings-command.js

@@ -0,0 +1,237 @@
+import { resolve, join } from "node:path";
+import { existsSync } from "node:fs";
+import chalk from "chalk";
+import { loadRawConfig, normalizeConfig } from "../config/index.js";
+import { validateForSettings } from "../config/validator.js";
+import { parseGitUrl, getRepoDisplayName, isGitHubRepo, } from "../shared/repo-detector.js";
+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 { 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.
+ */
+export async function runSettings(options, processorFactory = defaultRulesetProcessorFactory, repoProcessorFactory = defaultProcessorFactory, repoSettingsProcessorFactory = defaultRepoSettingsProcessorFactory) {
+    const configPath = resolve(options.config);
+    if (!existsSync(configPath)) {
+        console.error(`Config file not found: ${configPath}`);
+        process.exit(1);
+    }
+    console.log(`Loading config from: ${configPath}`);
+    if (options.dryRun) {
+        console.log("Running in DRY RUN mode - no changes will be made\n");
+    }
+    const rawConfig = loadRawConfig(configPath);
+    try {
+        validateForSettings(rawConfig);
+    }
+    catch (error) {
+        console.error(error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+    const config = normalizeConfig(rawConfig);
+    const reposWithRulesets = config.repos.filter((r) => r.settings?.rulesets && Object.keys(r.settings.rulesets).length > 0);
+    const reposWithRepoSettings = config.repos.filter((r) => r.settings?.repo && Object.keys(r.settings.repo).length > 0);
+    if (reposWithRulesets.length === 0 && reposWithRepoSettings.length === 0) {
+        console.log("No settings configured. Add settings.rulesets or settings.repo to your config.");
+        return;
+    }
+    if (reposWithRulesets.length > 0) {
+        console.log(`Found ${reposWithRulesets.length} repositories with rulesets`);
+    }
+    if (reposWithRepoSettings.length > 0) {
+        console.log(`Found ${reposWithRepoSettings.length} repositories with repo settings`);
+    }
+    console.log("");
+    logger.setTotal(reposWithRulesets.length + reposWithRepoSettings.length);
+    const processor = processorFactory();
+    const repoProcessor = repoProcessorFactory();
+    const results = [];
+    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;
+        try {
+            repoInfo = parseGitUrl(repoConfig.git, {
+                githubHosts: config.githubHosts,
+            });
+        }
+        catch (error) {
+            logger.error(i + 1, repoConfig.git, String(error));
+            results.push(buildErrorResult(repoConfig.git, 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");
+            // Skipped repos don't appear in the report
+            continue;
+        }
+        const managedRulesets = getManagedRulesets(null, config.id);
+        try {
+            logger.progress(i + 1, repoName, "Processing rulesets...");
+            const result = await processor.process(repoConfig, repoInfo, {
+                configId: config.id,
+                dryRun: options.dryRun,
+                managedRulesets,
+                noDelete: options.noDelete,
+            });
+            if (result.planOutput && result.planOutput.lines.length > 0) {
+                logger.info("");
+                logger.info(chalk.bold(`${repoName} - Rulesets:`));
+                for (const line of result.planOutput.lines) {
+                    logger.info(line);
+                }
+            }
+            if (result.skipped) {
+                logger.skip(i + 1, repoName, result.message);
+            }
+            else if (result.success) {
+                logger.success(i + 1, repoName, result.message);
+                if (result.manifestUpdate &&
+                    result.manifestUpdate.rulesets.length > 0) {
+                    const workDir = resolve(join(options.workDir ?? "./tmp", generateWorkspaceName(i)));
+                    logger.progress(i + 1, repoName, "Updating manifest...");
+                    const manifestResult = await repoProcessor.updateManifestOnly(repoInfo, repoConfig, {
+                        branchName: "chore/sync-rulesets",
+                        workDir,
+                        configId: config.id,
+                        dryRun: options.dryRun,
+                        retries: options.retries,
+                    }, result.manifestUpdate);
+                    if (!manifestResult.success && !manifestResult.skipped) {
+                        logger.info(`Warning: Failed to update manifest for ${repoName}: ${manifestResult.message}`);
+                    }
+                }
+            }
+            else {
+                logger.error(i + 1, repoName, result.message);
+            }
+            results.push({
+                repoName,
+                status: result.skipped
+                    ? "skipped"
+                    : result.success
+                        ? "succeeded"
+                        : "failed",
+                message: result.message,
+                rulesetPlanDetails: result.planOutput?.entries,
+            });
+            // 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));
+            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) {
+        const repoSettingsProcessor = repoSettingsProcessorFactory();
+        console.log(`\nProcessing repo settings for ${reposWithRepoSettings.length} repositories\n`);
+        for (let i = 0; i < reposWithRepoSettings.length; i++) {
+            const repoConfig = reposWithRepoSettings[i];
+            let repoInfo;
+            try {
+                repoInfo = parseGitUrl(repoConfig.git, {
+                    githubHosts: config.githubHosts,
+                });
+            }
+            catch (error) {
+                console.error(`Failed to parse ${repoConfig.git}: ${error}`);
+                getOrCreateResult(repoConfig.git).error =
+                    error instanceof Error ? error.message : String(error);
+                continue;
+            }
+            const repoName = getRepoDisplayName(repoInfo);
+            try {
+                const result = await repoSettingsProcessor.process(repoConfig, repoInfo, {
+                    dryRun: options.dryRun,
+                });
+                if (result.planOutput && result.planOutput.lines.length > 0) {
+                    console.log(`\n  ${chalk.bold(repoName)}:`);
+                    console.log("  Repo Settings:");
+                    for (const line of result.planOutput.lines) {
+                        console.log(line);
+                    }
+                    if (result.warnings && result.warnings.length > 0) {
+                        for (const warning of result.warnings) {
+                            console.log(chalk.yellow(`  ⚠️  Warning: ${warning}`));
+                        }
+                    }
+                }
+                if (result.skipped) {
+                    // Silent skip
+                }
+                else if (result.success) {
+                    console.log(chalk.green(`  ✓ ${repoName}: ${result.message}`));
+                }
+                else {
+                    console.log(chalk.red(`  ✗ ${repoName}: ${result.message}`));
+                }
+                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,
+                        });
+                    }
+                }
+                // Collect result for SettingsReport
+                if (!result.skipped) {
+                    getOrCreateResult(repoName).settingsResult = result;
+                }
+            }
+            catch (error) {
+                console.error(`  ✗ ${repoName}: ${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("");
+    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.d.ts

@@ -0,0 +1,25 @@
+import { MergeMode, MergeStrategy } from "../config/index.js";
+import { ProcessorFactory } from "./types.js";
+/**
+ * Shared options common to all commands.
+ */
+export interface SharedOptions {
+    config: string;
+    dryRun?: boolean;
+    workDir?: string;
+    retries?: number;
+    noDelete?: boolean;
+}
+/**
+ * Options specific to the sync command.
+ */
+export interface SyncOptions extends SharedOptions {
+    branch?: string;
+    merge?: MergeMode;
+    mergeStrategy?: MergeStrategy;
+    deleteBranch?: boolean;
+}
+/**
+ * Run the sync command - synchronizes files across repositories.
+ */
+export declare function runSync(options: SyncOptions, processorFactory?: ProcessorFactory): Promise<void>;

package/dist/cli/sync-command.js

@@ -0,0 +1,180 @@
+import { resolve, join } from "node:path";
+import { existsSync } from "node:fs";
+import { loadRawConfig, normalizeConfig, } from "../config/index.js";
+import { validateForSync } from "../config/validator.js";
+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 { 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
+ */
+function getUniqueFileNames(config) {
+    const fileNames = new Set();
+    for (const repo of config.repos) {
+        for (const file of repo.files) {
+            fileNames.add(file.fileName);
+        }
+    }
+    return Array.from(fileNames);
+}
+/**
+ * Generate default branch name based on files being synced
+ */
+function generateBranchName(fileNames) {
+    if (fileNames.length === 1) {
+        return `chore/sync-${sanitizeBranchName(fileNames[0])}`;
+    }
+    return "chore/sync-config";
+}
+/**
+ * Format file names for display
+ */
+function formatFileNames(fileNames) {
+    if (fileNames.length === 1) {
+        return fileNames[0];
+    }
+    if (fileNames.length <= 3) {
+        return fileNames.join(", ");
+    }
+    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.
+ */
+export async function runSync(options, processorFactory = defaultProcessorFactory) {
+    const configPath = resolve(options.config);
+    if (!existsSync(configPath)) {
+        console.error(`Config file not found: ${configPath}`);
+        process.exit(1);
+    }
+    console.log(`Loading config from: ${configPath}`);
+    if (options.dryRun) {
+        console.log("Running in DRY RUN mode - no changes will be made\n");
+    }
+    const rawConfig = loadRawConfig(configPath);
+    try {
+        validateForSync(rawConfig);
+    }
+    catch (error) {
+        console.error(error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+    const config = normalizeConfig(rawConfig);
+    const fileNames = getUniqueFileNames(config);
+    let branchName;
+    if (options.branch) {
+        validateBranchName(options.branch);
+        branchName = options.branch;
+    }
+    else {
+        branchName = generateBranchName(fileNames);
+    }
+    logger.setTotal(config.repos.length);
+    console.log(`Found ${config.repos.length} repositories to process`);
+    console.log(`Target files: ${formatFileNames(fileNames)}`);
+    console.log(`Branch: ${branchName}\n`);
+    const processor = processorFactory();
+    const reportResults = [];
+    for (let i = 0; i < config.repos.length; i++) {
+        const repoConfig = config.repos[i];
+        if (options.merge || options.mergeStrategy || options.deleteBranch) {
+            repoConfig.prOptions = {
+                ...repoConfig.prOptions,
+                merge: options.merge ?? repoConfig.prOptions?.merge,
+                mergeStrategy: options.mergeStrategy ?? repoConfig.prOptions?.mergeStrategy,
+                deleteBranch: options.deleteBranch ?? repoConfig.prOptions?.deleteBranch,
+            };
+        }
+        const current = i + 1;
+        let repoInfo;
+        try {
+            repoInfo = parseGitUrl(repoConfig.git, {
+                githubHosts: config.githubHosts,
+            });
+        }
+        catch (error) {
+            logger.error(current, repoConfig.git, String(error));
+            reportResults.push({
+                repoName: repoConfig.git,
+                success: false,
+                fileChanges: [],
+                error: error instanceof Error ? error.message : String(error),
+            });
+            continue;
+        }
+        const repoName = getRepoDisplayName(repoInfo);
+        const workDir = resolve(join(options.workDir ?? "./tmp", generateWorkspaceName(i)));
+        try {
+            logger.progress(current, repoName, "Processing...");
+            const result = await processor.process(repoConfig, repoInfo, {
+                branchName,
+                workDir,
+                configId: config.id,
+                dryRun: options.dryRun,
+                retries: options.retries,
+                prTemplate: config.prTemplate,
+                noDelete: options.noDelete,
+            });
+            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, result.message);
+            }
+            else {
+                logger.error(current, repoName, result.message);
+            }
+        }
+        catch (error) {
+            logger.error(current, repoName, 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("");
+    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 };
+}