@aspruyt/xfg 4.0.2 → 4.0.4

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

@@ -1,4 +1,3 @@
-import { defaultExecutor, } from "../../shared/command-executor.js";
 import { assertGitHubRepo, } from "../../shared/repo-detector.js";
 import { GhApiClient, parseApiJson, isHttp404Error, } from "../../shared/gh-api-utils.js";
 import { camelToSnake } from "../../shared/string-utils.js";
@@ -56,26 +55,19 @@ function configToGitHubPayload(settings) {
     }
     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 {
     api;
     constructor(executor, options) {
-        this.api = new GhApiClient(executor ?? defaultExecutor, options?.retries ?? 3);
+        this.api = new GhApiClient(executor, options.retries ?? 3, options.cwd);
     }
     async getSettings(repoInfo, options) {
         assertGitHubRepo(repoInfo, "GitHub Repo Settings strategy");
         const endpoint = `/repos/${repoInfo.owner}/${repoInfo.repo}`;
-        const result = await this.api.call("GET", endpoint, undefined, options);
+        const result = await this.api.call("GET", endpoint, { 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(repoInfo, options);
         // Pass vulnerability_alerts state - automated security fixes requires it enabled
         settings.automated_security_fixes = await this.getAutomatedSecurityFixes(repoInfo, options, settings.vulnerability_alerts);
@@ -91,30 +83,30 @@ export class GitHubRepoSettingsStrategy {
             return;
         }
         const endpoint = `/repos/${repoInfo.owner}/${repoInfo.repo}`;
-        await this.api.call("PATCH", endpoint, payload, options);
+        await this.api.call("PATCH", endpoint, { payload, options });
     }
     async setVulnerabilityAlerts(repoInfo, enable, options) {
         assertGitHubRepo(repoInfo, "GitHub Repo Settings strategy");
         const endpoint = `/repos/${repoInfo.owner}/${repoInfo.repo}/vulnerability-alerts`;
         const method = enable ? "PUT" : "DELETE";
-        await this.api.call(method, endpoint, undefined, options);
+        await this.api.call(method, endpoint, { options });
     }
     async setAutomatedSecurityFixes(repoInfo, enable, options) {
         assertGitHubRepo(repoInfo, "GitHub Repo Settings strategy");
         const endpoint = `/repos/${repoInfo.owner}/${repoInfo.repo}/automated-security-fixes`;
         const method = enable ? "PUT" : "DELETE";
-        await this.api.call(method, endpoint, undefined, options);
+        await this.api.call(method, endpoint, { options });
     }
     async setPrivateVulnerabilityReporting(repoInfo, enable, options) {
         assertGitHubRepo(repoInfo, "GitHub Repo Settings strategy");
         const endpoint = `/repos/${repoInfo.owner}/${repoInfo.repo}/private-vulnerability-reporting`;
         const method = enable ? "PUT" : "DELETE";
-        await this.api.call(method, endpoint, undefined, options);
+        await this.api.call(method, endpoint, { options });
     }
     async getVulnerabilityAlerts(github, options) {
         const endpoint = `/repos/${github.owner}/${github.repo}/vulnerability-alerts`;
         try {
-            await this.api.call("GET", endpoint, undefined, options);
+            await this.api.call("GET", endpoint, { options });
             return true; // 204 = enabled
         }
         catch (error) {
@@ -128,7 +120,7 @@ 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.api.call("GET", endpoint, undefined, options);
+            const result = await this.api.call("GET", endpoint, { options });
             // Parse JSON response - GitHub returns {"enabled": true/false}
             if (result) {
                 const data = parseApiJson(result, "automated security fixes response");
@@ -147,7 +139,7 @@ export class GitHubRepoSettingsStrategy {
     async getPrivateVulnerabilityReporting(github, options) {
         const endpoint = `/repos/${github.owner}/${github.repo}/private-vulnerability-reporting`;
         try {
-            const result = await this.api.call("GET", endpoint, undefined, options);
+            const result = await this.api.call("GET", endpoint, { options });
             const data = parseApiJson(result, "private vulnerability reporting response");
             return data.enabled === true;
         }

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

@@ -1,2 +1,3 @@
 export { RepoSettingsProcessor, type IRepoSettingsProcessor, } from "./processor.js";
+export { GitHubRepoSettingsStrategy } from "./github-repo-settings-strategy.js";
 export { type RepoSettingsPlanEntry } from "./formatter.js";

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

@@ -1,2 +1,4 @@
 // Processor
 export { RepoSettingsProcessor, } from "./processor.js";
+// Strategy
+export { GitHubRepoSettingsStrategy } from "./github-repo-settings-strategy.js";

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

@@ -12,9 +12,9 @@ export interface RepoSettingsProcessorResult extends BaseProcessorResult {
 }
 export declare class RepoSettingsProcessor implements IRepoSettingsProcessor {
     private readonly strategy;
-    constructor(strategy?: IRepoSettingsStrategy);
+    constructor(strategy: IRepoSettingsStrategy);
     process(repoConfig: RepoConfig, repoInfo: RepoInfo, options: RepoSettingsProcessorOptions): Promise<RepoSettingsProcessorResult>;
-    private processSettings;
+    private applySettings;
     private applyChanges;
     private validateSecuritySettings;
 }

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

@@ -1,23 +1,22 @@
-import { GitHubRepoSettingsStrategy } from "./github-repo-settings-strategy.js";
 import { diffRepoSettings, hasChanges } from "./diff.js";
 import { formatRepoSettingsPlan } from "./formatter.js";
 import { withGitHubGuards, buildDryRunResult, buildApplyResult, } from "../base-processor.js";
 export class RepoSettingsProcessor {
     strategy;
     constructor(strategy) {
-        this.strategy = strategy ?? new GitHubRepoSettingsStrategy();
+        this.strategy = strategy;
     }
     async process(repoConfig, repoInfo, options) {
         return withGitHubGuards(repoConfig, repoInfo, options, {
             hasDesiredSettings: (rc) => {
-                const s = rc.settings?.repo;
-                return !!s && Object.keys(s).length > 0;
+                const repoSettings = rc.settings?.repo;
+                return !!repoSettings && Object.keys(repoSettings).length > 0;
             },
             emptySettingsMessage: "No repo settings configured",
-            processSettings: (githubRepo, rc, opts, token, repoName) => this.processSettings(githubRepo, rc, opts, token, repoName),
+            applySettings: (githubRepo, rc, opts, token, repoName) => this.applySettings(githubRepo, rc, opts, token, repoName),
         });
     }
-    async processSettings(githubRepo, repoConfig, options, effectiveToken, repoName) {
+    async applySettings(githubRepo, repoConfig, options, effectiveToken, repoName) {
         const { dryRun } = options;
         const desiredSettings = repoConfig.settings.repo;
         const strategyOptions = { token: effectiveToken, host: githubRepo.host };

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

@@ -1,5 +1,5 @@
 import type { RepoInfo } from "../../shared/repo-detector.js";
-import type { GitHubRepoSettings } from "../../config/index.js";
+import type { GitHubRepoSettings, RepoVisibility, SquashMergeCommitTitle, SquashMergeCommitMessage, MergeCommitTitle, MergeCommitMessage } from "../../config/index.js";
 import type { GhApiOptions } from "../../shared/gh-api-utils.js";
 /**
  * Current repository settings from GitHub API (snake_case).
@@ -12,7 +12,7 @@ export interface CurrentRepoSettings {
     has_discussions?: boolean;
     is_template?: boolean;
     allow_forking?: boolean;
-    visibility?: string;
+    visibility?: RepoVisibility;
     archived?: boolean;
     allow_squash_merge?: boolean;
     allow_merge_commit?: boolean;
@@ -20,21 +20,21 @@ export interface CurrentRepoSettings {
     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;
+    squash_merge_commit_title?: SquashMergeCommitTitle;
+    squash_merge_commit_message?: SquashMergeCommitMessage;
+    merge_commit_title?: MergeCommitTitle;
+    merge_commit_message?: MergeCommitMessage;
     web_commit_signoff_required?: boolean;
     default_branch?: string;
     security_and_analysis?: {
         secret_scanning?: {
-            status: string;
+            status: "enabled" | "disabled";
         };
         secret_scanning_push_protection?: {
-            status: string;
+            status: "enabled" | "disabled";
         };
         secret_scanning_validity_checks?: {
-            status: string;
+            status: "enabled" | "disabled";
         };
     };
     owner_type?: "User" | "Organization";
@@ -64,7 +64,3 @@ export interface IRepoSettingsStrategy {
      */
     setPrivateVulnerabilityReporting(repoInfo: RepoInfo, enable: boolean, options?: GhApiOptions): Promise<void>;
 }
-/**
- * Type guard to check if an object implements IRepoSettingsStrategy.
- */
-export declare function isRepoSettingsStrategy(obj: unknown): obj is IRepoSettingsStrategy;

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

@@ -1,14 +1 @@
-/**
- * Type guard to check if an object implements IRepoSettingsStrategy.
- */
-export function isRepoSettingsStrategy(obj) {
-    if (typeof obj !== "object" || obj === null) {
-        return false;
-    }
-    const strategy = obj;
-    return (typeof strategy.getSettings === "function" &&
-        typeof strategy.updateSettings === "function" &&
-        typeof strategy.setVulnerabilityAlerts === "function" &&
-        typeof strategy.setAutomatedSecurityFixes === "function" &&
-        typeof strategy.setPrivateVulnerabilityReporting === "function");
-}
+export {};

package/dist/settings/rulesets/diff-algorithm.d.ts

@@ -5,7 +5,6 @@ export interface PropertyDiff {
     oldValue?: unknown;
     newValue?: unknown;
 }
-export declare function isObject(val: unknown): val is Record<string, unknown>;
 export declare function deepEqual(a: unknown, b: unknown): boolean;
 export declare function isArrayOfObjects(arr: unknown[]): boolean;
 /**

package/dist/settings/rulesets/diff-algorithm.js

@@ -1,7 +1,5 @@
 // src/settings/rulesets/diff-algorithm.ts
-export function isObject(val) {
-    return val !== null && typeof val === "object" && !Array.isArray(val);
-}
+import { isPlainObject } from "../../shared/type-guards.js";
 export function deepEqual(a, b) {
     if (a === b)
         return true;
@@ -14,7 +12,7 @@ export function deepEqual(a, b) {
             return false;
         return a.every((val, i) => deepEqual(val, b[i]));
     }
-    if (isObject(a) && isObject(b)) {
+    if (isPlainObject(a) && isPlainObject(b)) {
         const keysA = Object.keys(a);
         const keysB = Object.keys(b);
         if (keysA.length !== keysB.length)
@@ -24,7 +22,7 @@ export function deepEqual(a, b) {
     return false;
 }
 export function isArrayOfObjects(arr) {
-    return arr.length > 0 && arr.every((item) => isObject(item));
+    return arr.length > 0 && arr.every((item) => isPlainObject(item));
 }
 /**
  * Recursively compute property-level diffs between two objects.
@@ -46,7 +44,7 @@ export function computePropertyDiffs(current, desired, parentPath = []) {
         }
         else if (!deepEqual(currentVal, desiredVal)) {
             // Changed property
-            if (isObject(currentVal) && isObject(desiredVal)) {
+            if (isPlainObject(currentVal) && isPlainObject(desiredVal)) {
                 // Recurse into nested objects
                 diffs.push(...computePropertyDiffs(currentVal, desiredVal, path));
             }
@@ -75,7 +73,7 @@ export function computePropertyDiffs(current, desired, parentPath = []) {
  */
 function diffObjectArrays(currentArr, desiredArr, parentPath) {
     const diffs = [];
-    const hasType = desiredArr.every((item) => isObject(item) && "type" in item);
+    const hasType = desiredArr.every((item) => isPlainObject(item) && "type" in item);
     if (hasType) {
         // Match by type field
         const currentByType = new Map();
@@ -139,7 +137,7 @@ function diffObjectArrays(currentArr, desiredArr, parentPath) {
                     oldValue: currentArr[i],
                 });
             }
-            else if (isObject(currentArr[i]) && isObject(desiredArr[i])) {
+            else if (isPlainObject(currentArr[i]) && isPlainObject(desiredArr[i])) {
                 const itemDiffs = computePropertyDiffs(currentArr[i], desiredArr[i], [...parentPath, label]);
                 diffs.push(...itemDiffs);
             }

package/dist/settings/rulesets/formatter.js

@@ -1,6 +1,7 @@
 import chalk from "chalk";
 import { projectToDesiredShape, normalizeRuleset, } from "./diff.js";
-import { computePropertyDiffs, isObject, } from "./diff-algorithm.js";
+import { computePropertyDiffs, } from "./diff-algorithm.js";
+import { isPlainObject } from "../../shared/type-guards.js";
 /**
  * Build a tree structure from flat property diffs.
  */
@@ -67,7 +68,7 @@ function renderNestedValue(val, action, indent) {
     if (Array.isArray(val)) {
         for (let i = 0; i < val.length; i++) {
             const item = val[i];
-            if (isObject(item)) {
+            if (isPlainObject(item)) {
                 const obj = item;
                 const typeLabel = "type" in obj ? ` (${obj.type})` : "";
                 lines.push(style.color(`${indentStr}${style.symbol} [${i}]${typeLabel}:`));
@@ -78,7 +79,7 @@ function renderNestedValue(val, action, indent) {
             }
         }
     }
-    else if (isObject(val)) {
+    else if (isPlainObject(val)) {
         lines.push(...renderNestedObject(val, action, indent));
     }
     return lines;
@@ -90,11 +91,11 @@ function renderNestedObject(obj, action, indent) {
     for (const [key, value] of Object.entries(obj)) {
         if (value === null || value === undefined)
             continue;
-        if (Array.isArray(value) && value.some((v) => isObject(v))) {
+        if (Array.isArray(value) && value.some((v) => isPlainObject(v))) {
             lines.push(style.color(`${indentStr}${style.symbol} ${key}:`));
             lines.push(...renderNestedValue(value, action, indent + 1));
         }
-        else if (isObject(value)) {
+        else if (isPlainObject(value)) {
             lines.push(style.color(`${indentStr}${style.symbol} ${key}:`));
             lines.push(...renderNestedObject(value, action, indent + 1));
         }
@@ -135,12 +136,12 @@ function renderTree(node, indent = 0) {
         }
         else {
             // Leaf node with value
-            const hasComplexNew = isObject(child.newValue) ||
+            const hasComplexNew = isPlainObject(child.newValue) ||
                 (Array.isArray(child.newValue) &&
-                    child.newValue.some((v) => isObject(v)));
-            const hasComplexOld = isObject(child.oldValue) ||
+                    child.newValue.some((v) => isPlainObject(v)));
+            const hasComplexOld = isPlainObject(child.oldValue) ||
                 (Array.isArray(child.oldValue) &&
-                    child.oldValue.some((v) => isObject(v)));
+                    child.oldValue.some((v) => isPlainObject(v)));
             if (child.action === "add" && hasComplexNew) {
                 lines.push(style.color(`${indentStr}${style.symbol} ${child.name}:`));
                 lines.push(...renderNestedValue(child.newValue, child.action, indent + 1));
@@ -188,47 +189,10 @@ export function formatPropertyTree(diffs) {
 }
 /**
  * Format a full ruleset config as tree lines (for create action).
+ * Delegates to renderNestedObject which handles recursive rendering.
  */
 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;
+    return renderNestedObject(ruleset, "add", indent);
 }
 /**
  * Format ruleset changes as a Terraform-style plan.
@@ -244,11 +208,11 @@ export function formatRulesetPlan(changes) {
     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");
+    const unchangedItems = changes.filter((c) => c.action === "unchanged");
     creates = createChanges.length;
     updates = updateChanges.length;
     deletes = deleteChanges.length;
-    unchanged = unchangedChanges.length;
+    unchanged = unchangedItems.length;
     if (createChanges.length > 0) {
         lines.push(chalk.bold("  Create:"));
         for (const change of createChanges) {
@@ -305,7 +269,7 @@ export function formatRulesetPlan(changes) {
         }
         lines.push(""); // Blank line after deletes
     }
-    for (const change of unchangedChanges) {
+    for (const change of unchangedItems) {
         entries.push({ name: change.name, action: "unchanged" });
     }
     return { lines, creates, updates, deletes, unchanged, entries };

package/dist/settings/rulesets/github-ruleset-strategy.d.ts

@@ -17,33 +17,15 @@ interface GitHubRulesetPayload {
 }
 interface GitHubRulesetStrategyOptions {
     retries?: number;
+    cwd: string;
 }
-/**
- * GitHub Ruleset Strategy for managing repository rulesets via GitHub REST API.
- * Uses `gh api` CLI for authentication and API calls.
- */
 export declare class GitHubRulesetStrategy implements IRulesetStrategy {
     private api;
-    constructor(executor?: ICommandExecutor, options?: GitHubRulesetStrategyOptions);
-    /**
-     * Lists all rulesets for a repository.
-     */
+    constructor(executor: ICommandExecutor, options: GitHubRulesetStrategyOptions);
     list(repoInfo: RepoInfo, options?: GhApiOptions): Promise<GitHubRuleset[]>;
-    /**
-     * Gets a single ruleset by ID.
-     */
     get(repoInfo: RepoInfo, rulesetId: number, options?: GhApiOptions): Promise<GitHubRuleset>;
-    /**
-     * Creates a new ruleset.
-     */
     create(repoInfo: RepoInfo, name: string, ruleset: Ruleset, options?: GhApiOptions): Promise<GitHubRuleset>;
-    /**
-     * Updates an existing ruleset.
-     */
     update(repoInfo: RepoInfo, rulesetId: number, name: string, ruleset: Ruleset, options?: GhApiOptions): Promise<GitHubRuleset>;
-    /**
-     * Deletes a ruleset.
-     */
     delete(repoInfo: RepoInfo, rulesetId: number, options?: GhApiOptions): Promise<void>;
 }
 export {};

package/dist/settings/rulesets/github-ruleset-strategy.js

@@ -1,4 +1,3 @@
-import { defaultExecutor, } from "../../shared/command-executor.js";
 import { assertGitHubRepo } from "../../shared/repo-detector.js";
 import { camelToSnake } from "../../shared/string-utils.js";
 import { GhApiClient, parseApiJson, } from "../../shared/gh-api-utils.js";
@@ -33,10 +32,6 @@ export function configToGitHub(name, ruleset) {
     }
     return payload;
 }
-/**
- * Default parameters for pull_request rules.
- * GitHub API requires all parameters to be present.
- */
 const PULL_REQUEST_DEFAULTS = {
     required_approving_review_count: 0,
     dismiss_stale_reviews_on_push: false,
@@ -98,59 +93,40 @@ function convertValue(value) {
     }
     return value;
 }
-/**
- * GitHub Ruleset Strategy for managing repository rulesets via GitHub REST API.
- * Uses `gh api` CLI for authentication and API calls.
- */
 export class GitHubRulesetStrategy {
     api;
     constructor(executor, options) {
-        this.api = new GhApiClient(executor ?? defaultExecutor, options?.retries ?? 3);
+        this.api = new GhApiClient(executor, options.retries ?? 3, options.cwd);
     }
-    /**
-     * Lists all rulesets for a repository.
-     */
     async list(repoInfo, options) {
         assertGitHubRepo(repoInfo, "GitHub Ruleset strategy");
         const endpoint = `/repos/${repoInfo.owner}/${repoInfo.repo}/rulesets`;
-        const result = await this.api.call("GET", endpoint, undefined, options);
+        const result = await this.api.call("GET", endpoint, { options });
         return parseApiJson(result, "rulesets response");
     }
-    /**
-     * Gets a single ruleset by ID.
-     */
     async get(repoInfo, rulesetId, options) {
         assertGitHubRepo(repoInfo, "GitHub Ruleset strategy");
         const endpoint = `/repos/${repoInfo.owner}/${repoInfo.repo}/rulesets/${rulesetId}`;
-        const result = await this.api.call("GET", endpoint, undefined, options);
+        const result = await this.api.call("GET", endpoint, { options });
         return parseApiJson(result, "ruleset response");
     }
-    /**
-     * Creates a new ruleset.
-     */
     async create(repoInfo, name, ruleset, options) {
         assertGitHubRepo(repoInfo, "GitHub Ruleset strategy");
         const endpoint = `/repos/${repoInfo.owner}/${repoInfo.repo}/rulesets`;
         const payload = configToGitHub(name, ruleset);
-        const result = await this.api.call("POST", endpoint, payload, options);
+        const result = await this.api.call("POST", endpoint, { payload, options });
         return parseApiJson(result, "ruleset response");
     }
-    /**
-     * Updates an existing ruleset.
-     */
     async update(repoInfo, rulesetId, name, ruleset, options) {
         assertGitHubRepo(repoInfo, "GitHub Ruleset strategy");
         const endpoint = `/repos/${repoInfo.owner}/${repoInfo.repo}/rulesets/${rulesetId}`;
         const payload = configToGitHub(name, ruleset);
-        const result = await this.api.call("PUT", endpoint, payload, options);
+        const result = await this.api.call("PUT", endpoint, { payload, options });
         return parseApiJson(result, "ruleset response");
     }
-    /**
-     * Deletes a ruleset.
-     */
     async delete(repoInfo, rulesetId, options) {
         assertGitHubRepo(repoInfo, "GitHub Ruleset strategy");
         const endpoint = `/repos/${repoInfo.owner}/${repoInfo.repo}/rulesets/${rulesetId}`;
-        await this.api.call("DELETE", endpoint, undefined, options);
+        await this.api.call("DELETE", endpoint, { options });
     }
 }

package/dist/settings/rulesets/index.d.ts

@@ -1,3 +1,4 @@
-export { computePropertyDiffs, deepEqual, isObject, isArrayOfObjects, type PropertyDiff, } from "./diff-algorithm.js";
+export { computePropertyDiffs, deepEqual, isArrayOfObjects, type PropertyDiff, } from "./diff-algorithm.js";
 export { formatPropertyTree, type RulesetPlanEntry } from "./formatter.js";
 export { RulesetProcessor, type IRulesetProcessor } from "./processor.js";
+export { GitHubRulesetStrategy } from "./github-ruleset-strategy.js";

package/dist/settings/rulesets/index.js

@@ -1,6 +1,8 @@
 // Diff algorithm - property-level diffing for ruleset comparisons
-export { computePropertyDiffs, deepEqual, isObject, isArrayOfObjects, } from "./diff-algorithm.js";
+export { computePropertyDiffs, deepEqual, isArrayOfObjects, } from "./diff-algorithm.js";
 // Formatter
 export { formatPropertyTree } from "./formatter.js";
 // Processor
 export { RulesetProcessor } from "./processor.js";
+// Strategy
+export { GitHubRulesetStrategy } from "./github-ruleset-strategy.js";

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

@@ -17,7 +17,7 @@ export interface RulesetProcessorResult extends BaseProcessorResult {
  */
 export declare class RulesetProcessor implements IRulesetProcessor {
     private readonly strategy;
-    constructor(strategy?: IRulesetStrategy);
+    constructor(strategy: IRulesetStrategy);
     process(repoConfig: RepoConfig, repoInfo: RepoInfo, options: RulesetProcessorOptions): Promise<RulesetProcessorResult>;
-    private processSettings;
+    private applySettings;
 }

package/dist/settings/rulesets/processor.js

@@ -1,4 +1,3 @@
-import { GitHubRulesetStrategy } from "./github-ruleset-strategy.js";
 import { diffRulesets } from "./diff.js";
 import { formatRulesetPlan } from "./formatter.js";
 import { withGitHubGuards, countActions, buildDryRunResult, buildApplyResult, } from "../base-processor.js";
@@ -9,16 +8,16 @@ import { withGitHubGuards, countActions, buildDryRunResult, buildApplyResult, }
 export class RulesetProcessor {
     strategy;
     constructor(strategy) {
-        this.strategy = strategy ?? new GitHubRulesetStrategy();
+        this.strategy = strategy;
     }
     async process(repoConfig, repoInfo, options) {
         return withGitHubGuards(repoConfig, repoInfo, options, {
             hasDesiredSettings: (rc) => Object.keys(rc.settings?.rulesets ?? {}).length > 0,
             emptySettingsMessage: "No rulesets configured",
-            processSettings: (githubRepo, rc, opts, token, repoName) => this.processSettings(githubRepo, rc, opts, token, repoName),
+            applySettings: (githubRepo, rc, opts, token, repoName) => this.applySettings(githubRepo, rc, opts, token, repoName),
         });
     }
-    async processSettings(githubRepo, repoConfig, options, effectiveToken, repoName) {
+    async applySettings(githubRepo, repoConfig, options, effectiveToken, repoName) {
         const { dryRun, noDelete } = options;
         const settings = repoConfig.settings;
         const desiredRulesets = settings?.rulesets ?? {};

package/dist/{vcs → shared}/branch-utils.js

@@ -1,3 +1,4 @@
+import { ValidationError } from "./errors.js";
 export function sanitizeBranchName(fileName) {
     return fileName
         .toLowerCase()
@@ -12,18 +13,18 @@ export function sanitizeBranchName(fileName) {
  */
 export function validateBranchName(branchName) {
     if (!branchName || branchName.trim() === "") {
-        throw new Error("Branch name cannot be empty");
+        throw new ValidationError("Branch name cannot be empty");
     }
     if (branchName.startsWith(".") || branchName.startsWith("-")) {
-        throw new Error('Branch name cannot start with "." or "-"');
+        throw new ValidationError('Branch name cannot start with "." or "-"');
     }
     // Git disallows: space, ~, ^, :, ?, *, [, \, and consecutive dots (..)
     if (/[\s~^:?*[\\]/.test(branchName) || branchName.includes("..")) {
-        throw new Error("Branch name contains invalid characters");
+        throw new ValidationError("Branch name contains invalid characters");
     }
     if (branchName.endsWith("/") ||
         branchName.endsWith(".lock") ||
         branchName.endsWith(".")) {
-        throw new Error("Branch name has invalid ending");
+        throw new ValidationError("Branch name has invalid ending");
     }
 }

package/dist/shared/command-executor.d.ts

@@ -6,8 +6,9 @@ export interface ICommandExecutor {
     exec(command: string, cwd: string, options?: ExecOptions): Promise<string>;
 }
 export declare class ShellCommandExecutor implements ICommandExecutor {
+    private readonly baseEnv;
+    constructor(baseEnv: Record<string, string | undefined>);
     exec(command: string, cwd: string, options?: ExecOptions): Promise<string>;
 }
-export declare const defaultExecutor: ICommandExecutor;
 /** Extract stderr string from an exec error (child_process errors attach stderr). */
 export declare function getStderr(error: unknown): string;