@aspruyt/xfg 3.3.2 → 3.5.0

package/dist/repo-settings-processor.js

@@ -0,0 +1,96 @@
+import { isGitHubRepo, getRepoDisplayName } from "./repo-detector.js";
+import { GitHubRepoSettingsStrategy } from "./strategies/github-repo-settings-strategy.js";
+import { diffRepoSettings, hasChanges } from "./repo-settings-diff.js";
+import { formatRepoSettingsPlan, } from "./repo-settings-plan-formatter.js";
+export class RepoSettingsProcessor {
+    strategy;
+    constructor(strategy) {
+        this.strategy = strategy ?? new GitHubRepoSettingsStrategy();
+    }
+    async process(repoConfig, repoInfo, options) {
+        const repoName = getRepoDisplayName(repoInfo);
+        const { dryRun, token } = options;
+        // Check if this is a GitHub repo
+        if (!isGitHubRepo(repoInfo)) {
+            return {
+                success: true,
+                repoName,
+                message: `Skipped: ${repoName} is not a GitHub repository`,
+                skipped: true,
+            };
+        }
+        const githubRepo = repoInfo;
+        const desiredSettings = repoConfig.settings?.repo;
+        // If no repo settings configured, skip
+        if (!desiredSettings || Object.keys(desiredSettings).length === 0) {
+            return {
+                success: true,
+                repoName,
+                message: "No repo settings configured",
+                skipped: true,
+            };
+        }
+        try {
+            const strategyOptions = { token, host: githubRepo.host };
+            // Fetch current settings
+            const currentSettings = await this.strategy.getSettings(githubRepo, strategyOptions);
+            // Compute diff
+            const changes = diffRepoSettings(currentSettings, desiredSettings);
+            if (!hasChanges(changes)) {
+                return {
+                    success: true,
+                    repoName,
+                    message: "No changes needed",
+                    changes: { adds: 0, changes: 0 },
+                };
+            }
+            // Format plan output
+            const planOutput = formatRepoSettingsPlan(changes);
+            // Dry run mode - report planned changes without applying
+            if (dryRun) {
+                return {
+                    success: true,
+                    repoName,
+                    message: `[DRY RUN] ${planOutput.adds} to add, ${planOutput.changes} to change`,
+                    dryRun: true,
+                    changes: { adds: planOutput.adds, changes: planOutput.changes },
+                    warnings: planOutput.warnings,
+                    planOutput,
+                };
+            }
+            // Apply changes
+            await this.applyChanges(githubRepo, desiredSettings, strategyOptions);
+            return {
+                success: true,
+                repoName,
+                message: `Applied: ${planOutput.adds} added, ${planOutput.changes} changed`,
+                changes: { adds: planOutput.adds, changes: planOutput.changes },
+                warnings: planOutput.warnings,
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                success: false,
+                repoName,
+                message: `Failed: ${message}`,
+            };
+        }
+    }
+    async applyChanges(repoInfo, settings, options) {
+        // Extract settings that need separate API calls
+        const { vulnerabilityAlerts, automatedSecurityFixes, ...mainSettings } = settings;
+        // Update main settings via PATCH /repos
+        if (Object.keys(mainSettings).length > 0) {
+            await this.strategy.updateSettings(repoInfo, mainSettings, options);
+        }
+        // Handle vulnerability alerts (separate endpoint)
+        if (vulnerabilityAlerts !== undefined) {
+            await this.strategy.setVulnerabilityAlerts(repoInfo, vulnerabilityAlerts, options);
+        }
+        // Handle automated security fixes (separate endpoint)
+        if (automatedSecurityFixes !== undefined) {
+            await this.strategy.setAutomatedSecurityFixes(repoInfo, automatedSecurityFixes, options);
+        }
+    }
+}

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

@@ -0,0 +1,27 @@
+import type { RulesetChange } from "./ruleset-diff.js";
+export type DiffAction = "add" | "change" | "remove";
+export interface PropertyDiff {
+    path: string[];
+    action: DiffAction;
+    oldValue?: unknown;
+    newValue?: unknown;
+}
+export interface RulesetPlanResult {
+    lines: string[];
+    creates: number;
+    updates: number;
+    deletes: number;
+    unchanged: number;
+}
+/**
+ * Recursively compute property-level diffs between two objects.
+ */
+export declare function computePropertyDiffs(current: Record<string, unknown>, desired: Record<string, unknown>, parentPath?: string[]): PropertyDiff[];
+/**
+ * Format property diffs as an indented tree structure.
+ */
+export declare function formatPropertyTree(diffs: PropertyDiff[]): string[];
+/**
+ * Format ruleset changes as a Terraform-style plan.
+ */
+export declare function formatRulesetPlan(changes: RulesetChange[]): RulesetPlanResult;

package/dist/ruleset-plan-formatter.js

@@ -0,0 +1,314 @@
+// src/ruleset-plan-formatter.ts
+import chalk from "chalk";
+// =============================================================================
+// Property Diff Algorithm
+// =============================================================================
+/**
+ * Recursively compute property-level diffs between two objects.
+ */
+export function computePropertyDiffs(current, desired, parentPath = []) {
+    const diffs = [];
+    const allKeys = new Set([...Object.keys(current), ...Object.keys(desired)]);
+    for (const key of allKeys) {
+        const path = [...parentPath, key];
+        const currentVal = current[key];
+        const desiredVal = desired[key];
+        if (!(key in current)) {
+            // Added property
+            diffs.push({ path, action: "add", newValue: desiredVal });
+        }
+        else if (!(key in desired)) {
+            // Removed property
+            diffs.push({ path, action: "remove", oldValue: currentVal });
+        }
+        else if (!deepEqual(currentVal, desiredVal)) {
+            // Changed property
+            if (isObject(currentVal) && isObject(desiredVal)) {
+                // Recurse into nested objects
+                diffs.push(...computePropertyDiffs(currentVal, desiredVal, path));
+            }
+            else {
+                diffs.push({
+                    path,
+                    action: "change",
+                    oldValue: currentVal,
+                    newValue: desiredVal,
+                });
+            }
+        }
+        // Unchanged properties are not included
+    }
+    return diffs;
+}
+// =============================================================================
+// Helpers
+// =============================================================================
+function isObject(val) {
+    return val !== null && typeof val === "object" && !Array.isArray(val);
+}
+function deepEqual(a, b) {
+    if (a === b)
+        return true;
+    if (a === null || b === null || a === undefined || b === undefined)
+        return a === b;
+    if (typeof a !== typeof b)
+        return false;
+    if (Array.isArray(a) && Array.isArray(b)) {
+        if (a.length !== b.length)
+            return false;
+        return a.every((val, i) => deepEqual(val, b[i]));
+    }
+    if (isObject(a) && isObject(b)) {
+        const keysA = Object.keys(a);
+        const keysB = Object.keys(b);
+        if (keysA.length !== keysB.length)
+            return false;
+        return keysA.every((key) => deepEqual(a[key], b[key]));
+    }
+    return false;
+}
+/**
+ * Build a tree structure from flat property diffs.
+ */
+function buildTree(diffs) {
+    const root = { name: "", children: new Map() };
+    for (const diff of diffs) {
+        let current = root;
+        for (let i = 0; i < diff.path.length; i++) {
+            const segment = diff.path[i];
+            const isLast = i === diff.path.length - 1;
+            if (!current.children.has(segment)) {
+                current.children.set(segment, {
+                    name: segment,
+                    children: new Map(),
+                });
+            }
+            const child = current.children.get(segment);
+            if (isLast) {
+                child.action = diff.action;
+                child.oldValue = diff.oldValue;
+                child.newValue = diff.newValue;
+            }
+            else {
+                // Intermediate node - mark as change if any child changes
+                if (!child.action) {
+                    child.action = "change";
+                }
+            }
+            current = child;
+        }
+    }
+    return root;
+}
+/**
+ * Format a value for display.
+ */
+function formatValue(val) {
+    if (val === null)
+        return "null";
+    if (val === undefined)
+        return "undefined";
+    if (typeof val === "string")
+        return `"${val}"`;
+    if (Array.isArray(val)) {
+        if (val.length <= 3) {
+            return `[${val.map(formatValue).join(", ")}]`;
+        }
+        return `[${val.slice(0, 3).map(formatValue).join(", ")}, ... (${val.length - 3} more)]`;
+    }
+    if (typeof val === "object") {
+        return "{...}";
+    }
+    return String(val);
+}
+/**
+ * Get the symbol and color for an action.
+ */
+function getActionStyle(action) {
+    switch (action) {
+        case "add":
+            return { symbol: "+", color: chalk.green };
+        case "remove":
+            return { symbol: "-", color: chalk.red };
+        case "change":
+            return { symbol: "~", color: chalk.yellow };
+    }
+}
+/**
+ * Recursively render tree nodes to formatted lines.
+ */
+function renderTree(node, indent = 0) {
+    const lines = [];
+    const indentStr = "    ".repeat(indent);
+    for (const [, child] of node.children) {
+        const style = child.action
+            ? getActionStyle(child.action)
+            : { symbol: " ", color: chalk.gray };
+        const hasChildren = child.children.size > 0;
+        if (hasChildren) {
+            // Intermediate node
+            lines.push(style.color(`${indentStr}${style.symbol} ${child.name}:`));
+            lines.push(...renderTree(child, indent + 1));
+        }
+        else {
+            // Leaf node with value
+            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}`));
+        }
+    }
+    return lines;
+}
+/**
+ * Format property diffs as an indented tree structure.
+ */
+export function formatPropertyTree(diffs) {
+    if (diffs.length === 0) {
+        return [];
+    }
+    const tree = buildTree(diffs);
+    return renderTree(tree);
+}
+// =============================================================================
+// Ruleset Plan Formatter
+// =============================================================================
+/**
+ * Normalize a GitHubRuleset or Ruleset for comparison.
+ * Converts to snake_case and removes metadata fields.
+ */
+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();
+        result[snakeKey] = normalizeNestedValue(value);
+    }
+    return result;
+}
+function normalizeNestedValue(value) {
+    if (value === null || value === undefined)
+        return value;
+    if (Array.isArray(value))
+        return value.map(normalizeNestedValue);
+    if (typeof value === "object") {
+        const obj = value;
+        const result = {};
+        for (const [key, val] of Object.entries(obj)) {
+            const snakeKey = key.replace(/([A-Z])/g, "_$1").toLowerCase();
+            result[snakeKey] = normalizeNestedValue(val);
+        }
+        return result;
+    }
+    return value;
+}
+/**
+ * Format a full ruleset config as tree lines (for create action).
+ */
+function formatFullConfig(ruleset, indent = 2) {
+    const lines = [];
+    const style = getActionStyle("add");
+    function renderValue(key, value, currentIndent) {
+        const pad = "    ".repeat(currentIndent);
+        if (value === null || value === undefined)
+            return;
+        if (Array.isArray(value)) {
+            if (value.length === 0) {
+                lines.push(style.color(`${pad}+ ${key}: []`));
+            }
+            else if (value.every((v) => typeof v !== "object")) {
+                lines.push(style.color(`${pad}+ ${key}: ${formatValue(value)}`));
+            }
+            else {
+                lines.push(style.color(`${pad}+ ${key}:`));
+                for (const item of value) {
+                    if (typeof item === "object" && item !== null) {
+                        lines.push(style.color(`${pad}    - ${JSON.stringify(item)}`));
+                    }
+                    else {
+                        lines.push(style.color(`${pad}    - ${formatValue(item)}`));
+                    }
+                }
+            }
+        }
+        else if (typeof value === "object") {
+            lines.push(style.color(`${pad}+ ${key}:`));
+            for (const [k, v] of Object.entries(value)) {
+                renderValue(k, v, currentIndent + 1);
+            }
+        }
+        else {
+            lines.push(style.color(`${pad}+ ${key}: ${formatValue(value)}`));
+        }
+    }
+    for (const [key, value] of Object.entries(ruleset)) {
+        renderValue(key, value, indent);
+    }
+    return lines;
+}
+/**
+ * Format ruleset changes as a Terraform-style plan.
+ */
+export function formatRulesetPlan(changes) {
+    const lines = [];
+    let creates = 0;
+    let updates = 0;
+    let deletes = 0;
+    let unchanged = 0;
+    // Group by action type
+    const createChanges = changes.filter((c) => c.action === "create");
+    const updateChanges = changes.filter((c) => c.action === "update");
+    const deleteChanges = changes.filter((c) => c.action === "delete");
+    const unchangedChanges = changes.filter((c) => c.action === "unchanged");
+    creates = createChanges.length;
+    updates = updateChanges.length;
+    deletes = deleteChanges.length;
+    unchanged = unchangedChanges.length;
+    // Format creates
+    if (createChanges.length > 0) {
+        lines.push(chalk.bold("  Create:"));
+        for (const change of createChanges) {
+            lines.push(chalk.green(`    + ruleset "${change.name}"`));
+            if (change.desired) {
+                lines.push(...formatFullConfig(change.desired, 2));
+            }
+            lines.push(""); // Blank line between rulesets
+        }
+    }
+    // Format updates
+    if (updateChanges.length > 0) {
+        lines.push(chalk.bold("  Update:"));
+        for (const change of updateChanges) {
+            lines.push(chalk.yellow(`    ~ ruleset "${change.name}"`));
+            if (change.current && change.desired) {
+                const currentNorm = normalizeForDiff(change.current);
+                const desiredNorm = normalizeForDiff(change.desired);
+                const diffs = computePropertyDiffs(currentNorm, desiredNorm);
+                const treeLines = formatPropertyTree(diffs);
+                for (const line of treeLines) {
+                    lines.push(`        ${line}`);
+                }
+            }
+            lines.push(""); // Blank line between rulesets
+        }
+    }
+    // Format deletes
+    if (deleteChanges.length > 0) {
+        lines.push(chalk.bold("  Delete:"));
+        for (const change of deleteChanges) {
+            lines.push(chalk.red(`    - ruleset "${change.name}"`));
+        }
+        lines.push(""); // Blank line after deletes
+    }
+    return { lines, creates, updates, deletes, unchanged };
+}

package/dist/ruleset-processor.d.ts

@@ -1,6 +1,7 @@
 import type { RepoConfig } from "./config.js";
 import type { RepoInfo } from "./repo-detector.js";
 import { GitHubRulesetStrategy } from "./strategies/github-ruleset-strategy.js";
+import { RulesetPlanResult } from "./ruleset-plan-formatter.js";
 export interface IRulesetProcessor {
     process(repoConfig: RepoConfig, repoInfo: RepoInfo, options: RulesetProcessorOptions): Promise<RulesetProcessorResult>;
 }
@@ -26,6 +27,7 @@ export interface RulesetProcessorResult {
     manifestUpdate?: {
         rulesets: string[];
     };
+    planOutput?: RulesetPlanResult;
 }
 /**
  * Processes ruleset configuration for a repository.

package/dist/ruleset-processor.js

@@ -1,6 +1,7 @@
 import { isGitHubRepo, getRepoDisplayName } from "./repo-detector.js";
 import { GitHubRulesetStrategy } from "./strategies/github-ruleset-strategy.js";
 import { diffRulesets } from "./ruleset-diff.js";
+import { formatRulesetPlan, } from "./ruleset-plan-formatter.js";
 // =============================================================================
 // Processor Implementation
 // =============================================================================
@@ -60,12 +61,14 @@ export class RulesetProcessor {
             // Dry run mode - report planned changes without applying
             if (dryRun) {
                 const summary = this.formatChangeSummary(changeCounts);
+                const planOutput = formatRulesetPlan(changes);
                 return {
                     success: true,
                     repoName,
                     message: `[DRY RUN] ${summary}`,
                     dryRun: true,
                     changes: changeCounts,
+                    planOutput,
                     manifestUpdate: this.computeManifestUpdate(desiredRulesets, deleteOrphaned),
                 };
             }

package/dist/strategies/github-repo-settings-strategy.d.ts

@@ -0,0 +1,20 @@
+import { ICommandExecutor } from "../command-executor.js";
+import { RepoInfo } from "../repo-detector.js";
+import type { GitHubRepoSettings } from "../config.js";
+import type { IRepoSettingsStrategy, RepoSettingsStrategyOptions, CurrentRepoSettings } from "./repo-settings-strategy.js";
+/**
+ * GitHub Repository Settings Strategy.
+ * Manages repository settings via GitHub REST API using `gh api` CLI.
+ * Note: Uses exec via ICommandExecutor for gh CLI integration, consistent
+ * with other strategies in this codebase. Inputs are escaped via escapeShellArg.
+ */
+export declare class GitHubRepoSettingsStrategy implements IRepoSettingsStrategy {
+    private executor;
+    constructor(executor?: ICommandExecutor);
+    getSettings(repoInfo: RepoInfo, options?: RepoSettingsStrategyOptions): Promise<CurrentRepoSettings>;
+    updateSettings(repoInfo: RepoInfo, settings: GitHubRepoSettings, options?: RepoSettingsStrategyOptions): Promise<void>;
+    setVulnerabilityAlerts(repoInfo: RepoInfo, enable: boolean, options?: RepoSettingsStrategyOptions): Promise<void>;
+    setAutomatedSecurityFixes(repoInfo: RepoInfo, enable: boolean, options?: RepoSettingsStrategyOptions): Promise<void>;
+    private validateGitHub;
+    private ghApi;
+}

package/dist/strategies/github-repo-settings-strategy.js

@@ -0,0 +1,131 @@
+import { defaultExecutor } from "../command-executor.js";
+import { isGitHubRepo } from "../repo-detector.js";
+import { escapeShellArg } from "../shell-utils.js";
+/**
+ * Converts camelCase to snake_case.
+ */
+function camelToSnake(str) {
+    return str.replace(/([A-Z])/g, "_$1").toLowerCase();
+}
+/**
+ * Converts GitHubRepoSettings (camelCase) to GitHub API format (snake_case).
+ */
+function configToGitHubPayload(settings) {
+    const payload = {};
+    // Map config properties to API properties
+    const directMappings = [
+        "hasIssues",
+        "hasProjects",
+        "hasWiki",
+        "hasDiscussions",
+        "isTemplate",
+        "allowForking",
+        "visibility",
+        "archived",
+        "allowSquashMerge",
+        "allowMergeCommit",
+        "allowRebaseMerge",
+        "allowAutoMerge",
+        "deleteBranchOnMerge",
+        "allowUpdateBranch",
+        "squashMergeCommitTitle",
+        "squashMergeCommitMessage",
+        "mergeCommitTitle",
+        "mergeCommitMessage",
+    ];
+    for (const key of directMappings) {
+        if (settings[key] !== undefined) {
+            payload[camelToSnake(key)] = settings[key];
+        }
+    }
+    // Handle security_and_analysis for secret scanning
+    if (settings.secretScanning !== undefined ||
+        settings.secretScanningPushProtection !== undefined) {
+        payload.security_and_analysis = {
+            ...(settings.secretScanning !== undefined && {
+                secret_scanning: {
+                    status: settings.secretScanning ? "enabled" : "disabled",
+                },
+            }),
+            ...(settings.secretScanningPushProtection !== undefined && {
+                secret_scanning_push_protection: {
+                    status: settings.secretScanningPushProtection
+                        ? "enabled"
+                        : "disabled",
+                },
+            }),
+        };
+    }
+    return payload;
+}
+/**
+ * GitHub Repository Settings Strategy.
+ * Manages repository settings via GitHub REST API using `gh api` CLI.
+ * Note: Uses exec via ICommandExecutor for gh CLI integration, consistent
+ * with other strategies in this codebase. Inputs are escaped via escapeShellArg.
+ */
+export class GitHubRepoSettingsStrategy {
+    executor;
+    constructor(executor) {
+        this.executor = executor ?? defaultExecutor;
+    }
+    async getSettings(repoInfo, options) {
+        this.validateGitHub(repoInfo);
+        const github = repoInfo;
+        const endpoint = `/repos/${github.owner}/${github.repo}`;
+        const result = await this.ghApi("GET", endpoint, undefined, options);
+        return JSON.parse(result);
+    }
+    async updateSettings(repoInfo, settings, options) {
+        this.validateGitHub(repoInfo);
+        const github = repoInfo;
+        const payload = configToGitHubPayload(settings);
+        // Skip if no settings to update
+        if (Object.keys(payload).length === 0) {
+            return;
+        }
+        const endpoint = `/repos/${github.owner}/${github.repo}`;
+        await this.ghApi("PATCH", endpoint, payload, options);
+    }
+    async setVulnerabilityAlerts(repoInfo, enable, options) {
+        this.validateGitHub(repoInfo);
+        const github = repoInfo;
+        const endpoint = `/repos/${github.owner}/${github.repo}/vulnerability-alerts`;
+        const method = enable ? "PUT" : "DELETE";
+        await this.ghApi(method, endpoint, undefined, options);
+    }
+    async setAutomatedSecurityFixes(repoInfo, enable, options) {
+        this.validateGitHub(repoInfo);
+        const github = repoInfo;
+        const endpoint = `/repos/${github.owner}/${github.repo}/automated-security-fixes`;
+        const method = enable ? "PUT" : "DELETE";
+        await this.ghApi(method, endpoint, undefined, options);
+    }
+    validateGitHub(repoInfo) {
+        if (!isGitHubRepo(repoInfo)) {
+            throw new Error(`GitHub Repo Settings strategy requires GitHub repositories. Got: ${repoInfo.type}`);
+        }
+    }
+    async ghApi(method, endpoint, payload, options) {
+        const args = ["gh", "api"];
+        if (method !== "GET") {
+            args.push("-X", method);
+        }
+        if (options?.host && options.host !== "github.com") {
+            args.push("--hostname", escapeShellArg(options.host));
+        }
+        args.push(escapeShellArg(endpoint));
+        const baseCommand = args.join(" ");
+        const tokenPrefix = options?.token
+            ? `GH_TOKEN=${escapeShellArg(options.token)} `
+            : "";
+        if (payload &&
+            (method === "POST" || method === "PUT" || method === "PATCH")) {
+            const payloadJson = JSON.stringify(payload);
+            const command = `echo ${escapeShellArg(payloadJson)} | ${tokenPrefix}${baseCommand} --input -`;
+            return await this.executor.exec(command, process.cwd());
+        }
+        const command = `${tokenPrefix}${baseCommand}`;
+        return await this.executor.exec(command, process.cwd());
+    }
+}

package/dist/strategies/repo-settings-strategy.d.ts

@@ -0,0 +1,62 @@
+import type { RepoInfo } from "../repo-detector.js";
+import type { GitHubRepoSettings } from "../config.js";
+export interface RepoSettingsStrategyOptions {
+    token?: string;
+    host?: string;
+}
+/**
+ * Current repository settings from GitHub API (snake_case).
+ */
+export interface CurrentRepoSettings {
+    has_issues?: boolean;
+    has_projects?: boolean;
+    has_wiki?: boolean;
+    has_discussions?: boolean;
+    is_template?: boolean;
+    allow_forking?: boolean;
+    visibility?: string;
+    archived?: boolean;
+    allow_squash_merge?: boolean;
+    allow_merge_commit?: boolean;
+    allow_rebase_merge?: boolean;
+    allow_auto_merge?: boolean;
+    delete_branch_on_merge?: boolean;
+    allow_update_branch?: boolean;
+    squash_merge_commit_title?: string;
+    squash_merge_commit_message?: string;
+    merge_commit_title?: string;
+    merge_commit_message?: string;
+    security_and_analysis?: {
+        secret_scanning?: {
+            status: string;
+        };
+        secret_scanning_push_protection?: {
+            status: string;
+        };
+        secret_scanning_validity_checks?: {
+            status: string;
+        };
+    };
+}
+export interface IRepoSettingsStrategy {
+    /**
+     * Gets current repository settings.
+     */
+    getSettings(repoInfo: RepoInfo, options?: RepoSettingsStrategyOptions): Promise<CurrentRepoSettings>;
+    /**
+     * Updates repository settings.
+     */
+    updateSettings(repoInfo: RepoInfo, settings: GitHubRepoSettings, options?: RepoSettingsStrategyOptions): Promise<void>;
+    /**
+     * Enables or disables vulnerability alerts.
+     */
+    setVulnerabilityAlerts(repoInfo: RepoInfo, enable: boolean, options?: RepoSettingsStrategyOptions): Promise<void>;
+    /**
+     * Enables or disables automated security fixes.
+     */
+    setAutomatedSecurityFixes(repoInfo: RepoInfo, enable: boolean, options?: RepoSettingsStrategyOptions): Promise<void>;
+}
+/**
+ * Type guard to check if an object implements IRepoSettingsStrategy.
+ */
+export declare function isRepoSettingsStrategy(obj: unknown): obj is IRepoSettingsStrategy;