@aspruyt/xfg 4.0.0 → 4.0.1

package/dist/settings/labels/processor.d.ts

@@ -2,26 +2,13 @@ import type { RepoConfig } from "../../config/index.js";
 import type { RepoInfo } from "../../shared/repo-detector.js";
 import { type LabelsPlanResult } from "./formatter.js";
 import type { ILabelsStrategy } from "./types.js";
-export interface ILabelsProcessor {
-    process(repoConfig: RepoConfig, repoInfo: RepoInfo, options: LabelsProcessorOptions): Promise<LabelsProcessorResult>;
-}
-export interface LabelsProcessorOptions {
-    dryRun?: boolean;
+import { type BaseProcessorOptions, type BaseProcessorResult, type ISettingsProcessor, type ChangeCounts } from "../base-processor.js";
+export type ILabelsProcessor = ISettingsProcessor<LabelsProcessorOptions, LabelsProcessorResult>;
+export interface LabelsProcessorOptions extends BaseProcessorOptions {
     noDelete?: boolean;
-    token?: string;
 }
-export interface LabelsProcessorResult {
-    success: boolean;
-    repoName: string;
-    message: string;
-    skipped?: boolean;
-    dryRun?: boolean;
-    changes?: {
-        create: number;
-        update: number;
-        delete: number;
-        unchanged: number;
-    };
+export interface LabelsProcessorResult extends BaseProcessorResult {
+    changes?: ChangeCounts;
     planOutput?: LabelsPlanResult;
 }
 /**
@@ -30,18 +17,7 @@ export interface LabelsProcessorResult {
  */
 export declare class LabelsProcessor implements ILabelsProcessor {
     private readonly strategy;
-    private readonly tokenManager;
     constructor(strategy?: ILabelsStrategy);
-    /**
-     * Process labels for a single repository.
-     */
     process(repoConfig: RepoConfig, repoInfo: RepoInfo, options: LabelsProcessorOptions): Promise<LabelsProcessorResult>;
-    /**
-     * Format change counts into a summary string.
-     */
-    private formatChangeSummary;
-    /**
-     * Resolves a GitHub App installation token for the given repo.
-     */
-    private getInstallationToken;
+    private processSettings;
 }

package/dist/settings/labels/processor.js

@@ -1,176 +1,86 @@
-import { isGitHubRepo, getRepoDisplayName, } from "../../shared/repo-detector.js";
 import { GitHubLabelsStrategy } from "./github-labels-strategy.js";
 import { diffLabels } from "./diff.js";
 import { formatLabelsPlan } from "./formatter.js";
 import { labelConfigToPayload } from "./converter.js";
-import { hasGitHubAppCredentials } from "../../vcs/index.js";
-import { GitHubAppTokenManager } from "../../vcs/github-app-token-manager.js";
-// =============================================================================
-// Processor Implementation
-// =============================================================================
+import { withGitHubGuards, countActions, buildDryRunResult, buildApplyResult, } from "../base-processor.js";
 /**
  * Processes label configuration for a repository.
  * Handles create/update/delete operations via GitHub Labels API.
  */
 export class LabelsProcessor {
     strategy;
-    tokenManager;
     constructor(strategy) {
         this.strategy = strategy ?? new GitHubLabelsStrategy();
-        if (hasGitHubAppCredentials()) {
-            this.tokenManager = new GitHubAppTokenManager(process.env.XFG_GITHUB_APP_ID, process.env.XFG_GITHUB_APP_PRIVATE_KEY);
-        }
-        else {
-            this.tokenManager = null;
-        }
     }
-    /**
-     * Process labels for a single repository.
-     */
     async process(repoConfig, repoInfo, options) {
-        const repoName = getRepoDisplayName(repoInfo);
-        const { dryRun, noDelete, 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;
+        return withGitHubGuards(repoConfig, repoInfo, options, {
+            hasDesiredSettings: (rc) => Object.keys(rc.settings?.labels ?? {}).length > 0,
+            emptySettingsMessage: "No labels configured",
+            processSettings: (githubRepo, rc, opts, token, repoName) => this.processSettings(githubRepo, rc, opts, token, repoName),
+        });
+    }
+    async processSettings(githubRepo, repoConfig, options, effectiveToken, repoName) {
+        const { dryRun, noDelete } = options;
         const settings = repoConfig.settings;
         const desiredLabels = settings?.labels ?? {};
         const deleteOrphaned = settings?.deleteOrphaned ?? false;
-        // If no labels configured, skip
-        if (Object.keys(desiredLabels).length === 0) {
-            return {
-                success: true,
-                repoName,
-                message: "No labels configured",
-                skipped: true,
-            };
+        const strategyOptions = { token: effectiveToken, host: githubRepo.host };
+        const currentLabels = await this.strategy.list(githubRepo, strategyOptions);
+        // Compute diff
+        const changes = diffLabels(currentLabels, desiredLabels, deleteOrphaned, noDelete ?? false);
+        const changeCounts = countActions(changes);
+        const planOutput = formatLabelsPlan(changes);
+        if (dryRun) {
+            return buildDryRunResult(repoName, changeCounts, { planOutput });
         }
-        try {
-            // Resolve App token if available, fall back to provided token
-            const effectiveToken = token ?? (await this.getInstallationToken(githubRepo));
-            const strategyOptions = { token: effectiveToken, host: githubRepo.host };
-            const currentLabels = await this.strategy.list(githubRepo, strategyOptions);
-            // Compute diff
-            const changes = diffLabels(currentLabels, desiredLabels, deleteOrphaned, noDelete ?? false);
-            // Count changes by type
-            const changeCounts = {
-                create: changes.filter((c) => c.action === "create").length,
-                update: changes.filter((c) => c.action === "update").length,
-                delete: changes.filter((c) => c.action === "delete").length,
-                unchanged: changes.filter((c) => c.action === "unchanged").length,
-            };
-            const planOutput = formatLabelsPlan(changes);
-            // Dry run mode - report planned changes without applying
-            if (dryRun) {
-                const summary = this.formatChangeSummary(changeCounts);
-                return {
-                    success: true,
-                    repoName,
-                    message: `[DRY RUN] ${summary}`,
-                    dryRun: true,
-                    changes: changeCounts,
-                    planOutput,
-                };
-            }
-            // Apply changes (diff is already sorted: delete, update, create, unchanged)
-            let appliedCount = 0;
-            for (const change of changes) {
-                switch (change.action) {
-                    case "create":
-                        if (change.desired) {
-                            const payload = labelConfigToPayload(change.name, change.desired);
-                            await this.strategy.create(githubRepo, {
-                                name: payload.name,
-                                color: payload.color,
-                                ...(payload.description !== undefined
-                                    ? { description: payload.description }
-                                    : {}),
-                            }, strategyOptions);
-                            appliedCount++;
-                        }
-                        break;
-                    case "update":
-                        if (change.desired) {
-                            const updatePayload = {};
-                            for (const prop of change.propertyChanges ?? []) {
-                                if (prop.property === "color") {
-                                    updatePayload.color = prop.newValue;
-                                }
-                                else if (prop.property === "description") {
-                                    updatePayload.description = prop.newValue;
-                                }
-                                else if (prop.property === "new_name") {
-                                    updatePayload.new_name = prop.newValue;
-                                }
+        // Apply changes (diff is already sorted: delete, update, create, unchanged)
+        let appliedCount = 0;
+        for (const change of changes) {
+            switch (change.action) {
+                case "create":
+                    if (change.desired) {
+                        const payload = labelConfigToPayload(change.name, change.desired);
+                        await this.strategy.create(githubRepo, {
+                            name: payload.name,
+                            color: payload.color,
+                            ...(payload.description !== undefined
+                                ? { description: payload.description }
+                                : {}),
+                        }, strategyOptions);
+                        appliedCount++;
+                    }
+                    break;
+                case "update":
+                    if (change.desired) {
+                        const updatePayload = {};
+                        for (const prop of change.propertyChanges ?? []) {
+                            if (prop.property === "color") {
+                                updatePayload.color = prop.newValue;
+                            }
+                            else if (prop.property === "description") {
+                                updatePayload.description = prop.newValue;
+                            }
+                            else if (prop.property === "new_name") {
+                                updatePayload.new_name = prop.newValue;
                             }
-                            await this.strategy.update(githubRepo, change.name, updatePayload, strategyOptions);
-                            appliedCount++;
-                        }
-                        break;
-                    case "delete":
-                        if (!noDelete && deleteOrphaned) {
-                            await this.strategy.delete(githubRepo, change.name, strategyOptions);
-                            appliedCount++;
                         }
-                        break;
-                    case "unchanged":
-                        // No action needed
-                        break;
-                }
+                        await this.strategy.update(githubRepo, change.name, updatePayload, strategyOptions);
+                        appliedCount++;
+                    }
+                    break;
+                case "delete":
+                    if (!noDelete && deleteOrphaned) {
+                        await this.strategy.delete(githubRepo, change.name, strategyOptions);
+                        appliedCount++;
+                    }
+                    break;
+                case "unchanged":
+                    // No action needed
+                    break;
             }
-            const summary = this.formatChangeSummary(changeCounts);
-            return {
-                success: true,
-                repoName,
-                message: appliedCount > 0 ? `Applied: ${summary}` : "No changes needed",
-                changes: changeCounts,
-                planOutput,
-            };
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            return {
-                success: false,
-                repoName,
-                message: `Failed: ${message}`,
-            };
-        }
-    }
-    /**
-     * Format change counts into a summary string.
-     */
-    formatChangeSummary(counts) {
-        const parts = [];
-        if (counts.create > 0)
-            parts.push(`${counts.create} created`);
-        if (counts.update > 0)
-            parts.push(`${counts.update} updated`);
-        if (counts.delete > 0)
-            parts.push(`${counts.delete} deleted`);
-        if (counts.unchanged > 0)
-            parts.push(`${counts.unchanged} unchanged`);
-        return parts.length > 0 ? parts.join(", ") : "no changes";
-    }
-    /**
-     * Resolves a GitHub App installation token for the given repo.
-     */
-    async getInstallationToken(repoInfo) {
-        if (!this.tokenManager) {
-            return undefined;
-        }
-        try {
-            const token = await this.tokenManager.getTokenForRepo(repoInfo);
-            return token ?? undefined;
-        }
-        catch {
-            return undefined;
         }
+        return buildApplyResult(repoName, changeCounts, appliedCount, {
+            planOutput,
+        });
     }
 }

package/dist/settings/labels/types.d.ts

@@ -1,8 +1,5 @@
 import type { RepoInfo } from "../../shared/repo-detector.js";
-export interface LabelsStrategyOptions {
-    token?: string;
-    host?: string;
-}
+import type { GhApiOptions } from "../../shared/gh-api-utils.js";
 /**
  * GitHub label as returned by the API.
  */
@@ -18,16 +15,16 @@ export interface GitHubLabel {
  * Abstracts platform-specific API calls.
  */
 export interface ILabelsStrategy {
-    list(repoInfo: RepoInfo, options?: LabelsStrategyOptions): Promise<GitHubLabel[]>;
+    list(repoInfo: RepoInfo, options?: GhApiOptions): Promise<GitHubLabel[]>;
     create(repoInfo: RepoInfo, label: {
         name: string;
         color: string;
         description?: string;
-    }, options?: LabelsStrategyOptions): Promise<void>;
+    }, options?: GhApiOptions): Promise<void>;
     update(repoInfo: RepoInfo, currentName: string, label: {
         new_name?: string;
         color?: string;
         description?: string;
-    }, options?: LabelsStrategyOptions): Promise<void>;
-    delete(repoInfo: RepoInfo, name: string, options?: LabelsStrategyOptions): Promise<void>;
+    }, options?: GhApiOptions): Promise<void>;
+    delete(repoInfo: RepoInfo, name: string, options?: GhApiOptions): Promise<void>;
 }

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

@@ -7,8 +7,8 @@ export interface RepoSettingsPlanEntry {
 }
 export interface RepoSettingsPlanResult {
     lines: string[];
-    adds: number;
-    changes: number;
+    creates: number;
+    updates: number;
     warnings: string[];
     entries: RepoSettingsPlanEntry[];
 }

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

@@ -40,11 +40,11 @@ function getWarning(change) {
 export function formatRepoSettingsPlan(changes) {
     const lines = [];
     const warnings = [];
-    let adds = 0;
-    let changesCount = 0;
+    let creates = 0;
+    let updates = 0;
     const entries = [];
     if (changes.length === 0) {
-        return { lines, adds, changes: 0, warnings, entries };
+        return { lines, creates, updates, warnings, entries };
     }
     for (const change of changes) {
         const warning = getWarning(change);
@@ -53,7 +53,7 @@ export function formatRepoSettingsPlan(changes) {
         }
         if (change.action === "add") {
             lines.push(chalk.green(`    + ${change.property}: ${formatValue(change.newValue)}`));
-            adds++;
+            creates++;
             entries.push({
                 property: change.property,
                 action: "add",
@@ -62,7 +62,7 @@ export function formatRepoSettingsPlan(changes) {
         }
         else if (change.action === "change") {
             lines.push(chalk.yellow(`    ~ ${change.property}: ${formatValue(change.oldValue)} → ${formatValue(change.newValue)}`));
-            changesCount++;
+            updates++;
             entries.push({
                 property: change.property,
                 action: "change",
@@ -71,7 +71,7 @@ export function formatRepoSettingsPlan(changes) {
             });
         }
     }
-    return { lines, adds, changes: changesCount, warnings, entries };
+    return { lines, creates, updates, warnings, entries };
 }
 /**
  * Formats warnings for display.

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

@@ -1,8 +1,9 @@
 import { ICommandExecutor } from "../../shared/command-executor.js";
-import { RepoInfo } from "../../shared/repo-detector.js";
+import { type RepoInfo } from "../../shared/repo-detector.js";
+import { type GhApiOptions } from "../../shared/gh-api-utils.js";
 import type { GitHubRepoSettings } from "../../config/index.js";
-import type { IRepoSettingsStrategy, RepoSettingsStrategyOptions, CurrentRepoSettings } from "./types.js";
-export interface GitHubRepoSettingsStrategyOptions {
+import type { IRepoSettingsStrategy, CurrentRepoSettings } from "./types.js";
+interface GitHubRepoSettingsStrategyOptions {
     retries?: number;
 }
 /**
@@ -12,17 +13,15 @@ export interface GitHubRepoSettingsStrategyOptions {
  * with other strategies in this codebase. Inputs are escaped via escapeShellArg.
  */
 export declare class GitHubRepoSettingsStrategy implements IRepoSettingsStrategy {
-    private executor;
-    private retries;
+    private api;
     constructor(executor?: ICommandExecutor, options?: GitHubRepoSettingsStrategyOptions);
-    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>;
-    setPrivateVulnerabilityReporting(repoInfo: RepoInfo, enable: boolean, options?: RepoSettingsStrategyOptions): Promise<void>;
+    getSettings(repoInfo: RepoInfo, options?: GhApiOptions): Promise<CurrentRepoSettings>;
+    updateSettings(repoInfo: RepoInfo, settings: GitHubRepoSettings, options?: GhApiOptions): Promise<void>;
+    setVulnerabilityAlerts(repoInfo: RepoInfo, enable: boolean, options?: GhApiOptions): Promise<void>;
+    setAutomatedSecurityFixes(repoInfo: RepoInfo, enable: boolean, options?: GhApiOptions): Promise<void>;
+    setPrivateVulnerabilityReporting(repoInfo: RepoInfo, enable: boolean, options?: GhApiOptions): Promise<void>;
     private getVulnerabilityAlerts;
     private getAutomatedSecurityFixes;
     private getPrivateVulnerabilityReporting;
-    private validateGitHub;
-    private ghApi;
 }
+export {};

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

@@ -1,13 +1,7 @@
 import { defaultExecutor, } from "../../shared/command-executor.js";
-import { isGitHubRepo, } from "../../shared/repo-detector.js";
-import { escapeShellArg } from "../../shared/shell-utils.js";
-import { withRetry } from "../../shared/retry-utils.js";
-/**
- * Converts camelCase to snake_case.
- */
-function camelToSnake(str) {
-    return str.replace(/([A-Z])/g, "_$1").toLowerCase();
-}
+import { assertGitHubRepo, } from "../../shared/repo-detector.js";
+import { GhApiClient, parseApiJson, isHttp404Error, } from "../../shared/gh-api-utils.js";
+import { camelToSnake } from "../../shared/string-utils.js";
 /**
  * Converts GitHubRepoSettings (camelCase) to GitHub API format (snake_case).
  */
@@ -69,70 +63,62 @@ function configToGitHubPayload(settings) {
  * with other strategies in this codebase. Inputs are escaped via escapeShellArg.
  */
 export class GitHubRepoSettingsStrategy {
-    executor;
-    retries;
+    api;
     constructor(executor, options) {
-        this.executor = executor ?? defaultExecutor;
-        this.retries = options?.retries ?? 3;
+        this.api = new GhApiClient(executor ?? defaultExecutor, options?.retries ?? 3);
     }
     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);
-        const parsed = JSON.parse(result);
+        assertGitHubRepo(repoInfo, "GitHub Repo Settings strategy");
+        const endpoint = `/repos/${repoInfo.owner}/${repoInfo.repo}`;
+        const result = await this.api.call("GET", endpoint, undefined, options);
+        const parsed = parseApiJson(result, "repo settings response");
         const settings = parsed;
         // Extract owner type from nested API response
         settings.owner_type = parsed.owner?.type;
         // Fetch security settings from separate endpoints
-        settings.vulnerability_alerts = await this.getVulnerabilityAlerts(github, options);
+        settings.vulnerability_alerts = await this.getVulnerabilityAlerts(repoInfo, options);
         // Pass vulnerability_alerts state - automated security fixes requires it enabled
-        settings.automated_security_fixes = await this.getAutomatedSecurityFixes(github, options, settings.vulnerability_alerts);
+        settings.automated_security_fixes = await this.getAutomatedSecurityFixes(repoInfo, options, settings.vulnerability_alerts);
         settings.private_vulnerability_reporting =
-            await this.getPrivateVulnerabilityReporting(github, options);
+            await this.getPrivateVulnerabilityReporting(repoInfo, options);
         return settings;
     }
     async updateSettings(repoInfo, settings, options) {
-        this.validateGitHub(repoInfo);
-        const github = repoInfo;
+        assertGitHubRepo(repoInfo, "GitHub Repo Settings strategy");
         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);
+        const endpoint = `/repos/${repoInfo.owner}/${repoInfo.repo}`;
+        await this.api.call("PATCH", endpoint, payload, options);
     }
     async setVulnerabilityAlerts(repoInfo, enable, options) {
-        this.validateGitHub(repoInfo);
-        const github = repoInfo;
-        const endpoint = `/repos/${github.owner}/${github.repo}/vulnerability-alerts`;
+        assertGitHubRepo(repoInfo, "GitHub Repo Settings strategy");
+        const endpoint = `/repos/${repoInfo.owner}/${repoInfo.repo}/vulnerability-alerts`;
         const method = enable ? "PUT" : "DELETE";
-        await this.ghApi(method, endpoint, undefined, options);
+        await this.api.call(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`;
+        assertGitHubRepo(repoInfo, "GitHub Repo Settings strategy");
+        const endpoint = `/repos/${repoInfo.owner}/${repoInfo.repo}/automated-security-fixes`;
         const method = enable ? "PUT" : "DELETE";
-        await this.ghApi(method, endpoint, undefined, options);
+        await this.api.call(method, endpoint, undefined, options);
     }
     async setPrivateVulnerabilityReporting(repoInfo, enable, options) {
-        this.validateGitHub(repoInfo);
-        const github = repoInfo;
-        const endpoint = `/repos/${github.owner}/${github.repo}/private-vulnerability-reporting`;
+        assertGitHubRepo(repoInfo, "GitHub Repo Settings strategy");
+        const endpoint = `/repos/${repoInfo.owner}/${repoInfo.repo}/private-vulnerability-reporting`;
         const method = enable ? "PUT" : "DELETE";
-        await this.ghApi(method, endpoint, undefined, options);
+        await this.api.call(method, endpoint, undefined, options);
     }
     async getVulnerabilityAlerts(github, options) {
         const endpoint = `/repos/${github.owner}/${github.repo}/vulnerability-alerts`;
         try {
-            await this.ghApi("GET", endpoint, undefined, options);
+            await this.api.call("GET", endpoint, undefined, options);
             return true; // 204 = enabled
         }
         catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            if (message.includes("HTTP 404")) {
+            if (isHttp404Error(error)) {
                 return false; // 404 = disabled
             }
             throw error; // Re-throw other errors
@@ -142,18 +128,17 @@ export class GitHubRepoSettingsStrategy {
         // Note: GitHub returns JSON with {enabled: boolean} for this endpoint
         const endpoint = `/repos/${github.owner}/${github.repo}/automated-security-fixes`;
         try {
-            const result = await this.ghApi("GET", endpoint, undefined, options);
+            const result = await this.api.call("GET", endpoint, undefined, options);
             // Parse JSON response - GitHub returns {"enabled": true/false}
             if (result) {
-                const data = JSON.parse(result);
+                const data = parseApiJson(result, "automated security fixes response");
                 return data.enabled === true;
             }
             // Empty response (204) means enabled
             return true;
         }
         catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            if (message.includes("HTTP 404")) {
+            if (isHttp404Error(error)) {
                 return false;
             }
             throw error;
@@ -162,47 +147,15 @@ export class GitHubRepoSettingsStrategy {
     async getPrivateVulnerabilityReporting(github, options) {
         const endpoint = `/repos/${github.owner}/${github.repo}/private-vulnerability-reporting`;
         try {
-            const result = await this.ghApi("GET", endpoint, undefined, options);
-            const data = JSON.parse(result);
+            const result = await this.api.call("GET", endpoint, undefined, options);
+            const data = parseApiJson(result, "private vulnerability reporting response");
             return data.enabled === true;
         }
         catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            if (message.includes("HTTP 404")) {
+            if (isHttp404Error(error)) {
                 return false; // 404 = not available (e.g. private repos)
             }
             throw error; // Re-throw other errors
         }
     }
-    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 withRetry(() => this.executor.exec(command, process.cwd()), {
-                retries: this.retries,
-            });
-        }
-        const command = `${tokenPrefix}${baseCommand}`;
-        return await withRetry(() => this.executor.exec(command, process.cwd()), {
-            retries: this.retries,
-        });
-    }
 }

package/dist/settings/repo-settings/index.d.ts

@@ -1,5 +1,2 @@
-export { isRepoSettingsStrategy, type IRepoSettingsStrategy, type RepoSettingsStrategyOptions, type CurrentRepoSettings, } from "./types.js";
-export { RepoSettingsProcessor, type IRepoSettingsProcessor, type RepoSettingsProcessorOptions, type RepoSettingsProcessorResult, } from "./processor.js";
-export { diffRepoSettings, hasChanges, type RepoSettingsAction, type RepoSettingsChange, } from "./diff.js";
-export { formatRepoSettingsPlan, type RepoSettingsPlanResult, type RepoSettingsPlanEntry, } from "./formatter.js";
-export { GitHubRepoSettingsStrategy } from "./github-repo-settings-strategy.js";
+export { RepoSettingsProcessor, type IRepoSettingsProcessor, } from "./processor.js";
+export { type RepoSettingsPlanEntry } from "./formatter.js";

package/dist/settings/repo-settings/index.js

@@ -1,10 +1,2 @@
-// Types
-export { isRepoSettingsStrategy, } from "./types.js";
-// Repo settings processor
+// Processor
 export { RepoSettingsProcessor, } from "./processor.js";
-// Repo settings diff
-export { diffRepoSettings, hasChanges, } from "./diff.js";
-// Repo settings formatter
-export { formatRepoSettingsPlan, } from "./formatter.js";
-// Repo settings strategies
-export { GitHubRepoSettingsStrategy } from "./github-repo-settings-strategy.js";