@aspruyt/xfg 3.7.5 → 3.7.7

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,228 @@
+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 { printPlan } from "../output/plan-formatter.js";
+import { writePlanSummary } from "../output/plan-summary.js";
+import { rulesetResultToResources, repoSettingsResultToResources, } from "../settings/resource-converters.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 plan = { resources: [], errors: [] };
+    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));
+            plan.errors.push({
+                repo: repoConfig.git,
+                message: 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",
+                    });
+                }
+            }
+            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,
+            });
+            plan.resources.push(...rulesetResultToResources(repoName, 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),
+            });
+        }
+    }
+    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}`);
+                plan.errors.push({
+                    repo: repoConfig.git,
+                    message: 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,
+                        });
+                    }
+                }
+                plan.resources.push(...repoSettingsResultToResources(repoName, result));
+            }
+            catch (error) {
+                console.error(`  ✗ ${repoName}: ${error}`);
+                plan.errors.push({
+                    repo: repoName,
+                    message: error instanceof Error ? error.message : String(error),
+                });
+            }
+        }
+    }
+    console.log("");
+    printPlan(plan);
+    writePlanSummary(plan, {
+        title: "Repository Settings Summary",
+        dryRun: options.dryRun ?? false,
+    });
+    if (plan.errors && plan.errors.length > 0) {
+        process.exit(1);
+    }
+}

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,155 @@
+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 { 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";
+/**
+ * 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`;
+}
+/**
+ * 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 results = [];
+    const plan = { resources: [], errors: [] };
+    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));
+            results.push(buildErrorResult(repoConfig.git, error));
+            plan.errors.push({
+                repo: repoConfig.git,
+                message: 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 repoResult = buildRepoResult(repoName, repoConfig, result);
+            results.push(repoResult);
+            if (result.skipped) {
+                logger.skip(current, repoName, result.message);
+            }
+            else if (result.success) {
+                logger.success(current, repoName, repoResult.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),
+            });
+        }
+    }
+    console.log("");
+    printPlan(plan);
+    writePlanSummary(plan, {
+        title: "Config Sync Summary",
+        dryRun: options.dryRun ?? false,
+    });
+    if (plan.errors && plan.errors.length > 0) {
+        process.exit(1);
+    }
+}

package/dist/cli/types.d.ts

@@ -0,0 +1,45 @@
+import { RepoConfig } from "../config/index.js";
+import { RepoInfo } from "../shared/repo-detector.js";
+import { type ProcessorResult, type ProcessorOptions } from "../sync/index.js";
+import { RulesetProcessorOptions, RulesetProcessorResult } from "../settings/rulesets/processor.js";
+import { type IRepoSettingsProcessor } from "../settings/repo-settings/processor.js";
+/**
+ * Processor interface for dependency injection in tests.
+ */
+export interface IRepositoryProcessor {
+    process(repoConfig: RepoConfig, repoInfo: RepoInfo, options: ProcessorOptions): Promise<ProcessorResult>;
+    updateManifestOnly(repoInfo: RepoInfo, repoConfig: RepoConfig, options: ProcessorOptions, manifestUpdate: {
+        rulesets: string[];
+    }): Promise<ProcessorResult>;
+}
+/**
+ * Factory function type for creating processors.
+ */
+export type ProcessorFactory = () => IRepositoryProcessor;
+/**
+ * Default factory that creates a real RepositoryProcessor.
+ */
+export declare const defaultProcessorFactory: ProcessorFactory;
+/**
+ * Ruleset processor interface for dependency injection in tests.
+ */
+export interface IRulesetProcessor {
+    process(repoConfig: RepoConfig, repoInfo: RepoInfo, options: RulesetProcessorOptions): Promise<RulesetProcessorResult>;
+}
+/**
+ * Factory function type for creating ruleset processors.
+ */
+export type RulesetProcessorFactory = () => IRulesetProcessor;
+/**
+ * Default factory that creates a real RulesetProcessor.
+ */
+export declare const defaultRulesetProcessorFactory: RulesetProcessorFactory;
+/**
+ * Repo settings processor factory function type.
+ */
+export type RepoSettingsProcessorFactory = () => IRepoSettingsProcessor;
+/**
+ * Default factory that creates a real RepoSettingsProcessor.
+ */
+export declare const defaultRepoSettingsProcessorFactory: RepoSettingsProcessorFactory;
+export type { IRepoSettingsProcessor };

package/dist/cli/types.js

@@ -0,0 +1,15 @@
+import { RepositoryProcessor, } from "../sync/index.js";
+import { RulesetProcessor, } from "../settings/rulesets/processor.js";
+import { RepoSettingsProcessor, } from "../settings/repo-settings/processor.js";
+/**
+ * Default factory that creates a real RepositoryProcessor.
+ */
+export const defaultProcessorFactory = () => new RepositoryProcessor();
+/**
+ * Default factory that creates a real RulesetProcessor.
+ */
+export const defaultRulesetProcessorFactory = () => new RulesetProcessor();
+/**
+ * Default factory that creates a real RepoSettingsProcessor.
+ */
+export const defaultRepoSettingsProcessorFactory = () => new RepoSettingsProcessor();

package/dist/cli.js

@@ -1,20 +1,3 @@
 #!/usr/bin/env node
-import { program } from "./index.js";
-// Handle backwards compatibility: if no subcommand is provided, default to sync
-// This maintains compatibility with existing usage like `xfg -c config.yaml`
-const args = process.argv.slice(2);
-const subcommands = ["sync", "settings", "help"];
-const versionFlags = ["-V", "--version"];
-// Check if the first argument is a subcommand or version flag
-const firstArg = args[0];
-const isSubcommand = firstArg && subcommands.includes(firstArg);
-const isVersionFlag = firstArg && versionFlags.includes(firstArg);
-if (isSubcommand || isVersionFlag) {
-    // Explicit subcommand or version flag - parse normally
-    program.parse();
-}
-else {
-    // No subcommand - prepend 'sync' for backwards compatibility
-    // This handles: `xfg -c config.yaml`, `xfg --help`, `xfg` (no args)
-    program.parse(["node", "xfg", "sync", ...args]);
-}
+import { program } from "./cli/program.js";
+program.parse();

package/dist/{file-reference-resolver.d.ts → config/file-reference-resolver.d.ts}

@@ -1,4 +1,4 @@
-import type { ContentValue, RawConfig } from "./config.js";
+import type { ContentValue, RawConfig } from "./types.js";
 export interface FileReferenceOptions {
     configDir: string;
 }

package/dist/config/index.d.ts

@@ -0,0 +1,7 @@
+export type { MergeMode, MergeStrategy, PRMergeOptions, RulesetTarget, RulesetEnforcement, BypassActorType, BypassMode, PatternOperator, MergeMethod, AlertsThreshold, SecurityAlertsThreshold, BypassActor, RefNameCondition, RulesetConditions, StatusCheckConfig, RequiredReviewer, CodeScanningTool, WorkflowConfig, PullRequestRuleParameters, RequiredStatusChecksParameters, UpdateRuleParameters, RequiredDeploymentsParameters, CodeScanningParameters, CodeQualityParameters, WorkflowsParameters, PatternRuleParameters, FilePathRestrictionParameters, FileExtensionRestrictionParameters, MaxFilePathLengthParameters, MaxFileSizeParameters, PullRequestRule, RequiredStatusChecksRule, RequiredSignaturesRule, RequiredLinearHistoryRule, NonFastForwardRule, CreationRule, UpdateRule, DeletionRule, RequiredDeploymentsRule, CodeScanningRule, CodeQualityRule, WorkflowsRule, CommitAuthorEmailPatternRule, CommitMessagePatternRule, CommitterEmailPatternRule, BranchNamePatternRule, TagNamePatternRule, FilePathRestrictionRule, FileExtensionRestrictionRule, MaxFilePathLengthRule, MaxFileSizeRule, RulesetRule, Ruleset, SquashMergeCommitTitle, SquashMergeCommitMessage, MergeCommitTitle, MergeCommitMessage, RepoVisibility, GitHubRepoSettings, RepoSettings, ContentValue, RawFileConfig, RawRepoFileOverride, RawRepoSettings, RawRepoConfig, RawConfig, FileContent, RepoConfig, Config, } from "./types.js";
+export { RULESET_FIELD_MAP, RULESET_COMPARABLE_FIELDS } from "./types.js";
+export { loadRawConfig, loadConfig, normalizeConfig } from "./loader.js";
+export { convertContentToString, detectOutputFormat, type OutputFormat, type ConvertOptions, } from "./formatter.js";
+export { isFileReference, resolveFileReference, type FileReferenceOptions, } from "./file-reference-resolver.js";
+export { arrayMergeStrategies, deepMerge, stripMergeDirectives, createMergeContext, isTextContent, mergeTextContent, type ArrayMergeStrategy, type ArrayMergeHandler, type MergeContext, } from "./merge.js";
+export { validateRawConfig, validateSettings, validateForSync, validateForSettings, hasActionableSettings, } from "./validator.js";

package/dist/config/index.js

@@ -0,0 +1,12 @@
+// Re-export values (non-type exports)
+export { RULESET_FIELD_MAP, RULESET_COMPARABLE_FIELDS } from "./types.js";
+// Re-export loading functions
+export { loadRawConfig, loadConfig, normalizeConfig } from "./loader.js";
+// Config formatting
+export { convertContentToString, detectOutputFormat, } from "./formatter.js";
+// File reference resolution
+export { isFileReference, resolveFileReference, } from "./file-reference-resolver.js";
+// Deep merge utilities
+export { arrayMergeStrategies, deepMerge, stripMergeDirectives, createMergeContext, isTextContent, mergeTextContent, } from "./merge.js";
+// Validation
+export { validateRawConfig, validateSettings, validateForSync, validateForSettings, hasActionableSettings, } from "./validator.js";

package/dist/config/loader.d.ts

@@ -0,0 +1,9 @@
+import { normalizeConfig as normalizeConfigInternal } from "./normalizer.js";
+import type { RawConfig, Config } from "./types.js";
+export { normalizeConfigInternal as normalizeConfig };
+/**
+ * Load and validate raw config without normalization.
+ * Use this when you need to perform command-specific validation before normalizing.
+ */
+export declare function loadRawConfig(filePath: string): RawConfig;
+export declare function loadConfig(filePath: string): Config;