@aspruyt/json-config-sync 2.0.2 → 2.1.0

package/dist/git-ops.js

@@ -1,20 +1,61 @@
-import { execSync } from 'node:child_process';
-import { rmSync, existsSync, mkdirSync, writeFileSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { escapeShellArg } from './shell-utils.js';
+import { rmSync, existsSync, mkdirSync, writeFileSync, readFileSync, } from "node:fs";
+import { join, resolve, relative, isAbsolute } from "node:path";
+import { escapeShellArg } from "./shell-utils.js";
+import { defaultExecutor } from "./command-executor.js";
+import { withRetry } from "./retry-utils.js";
+import { logger } from "./logger.js";
+/**
+ * Patterns indicating a git branch does not exist.
+ * Used to distinguish "branch not found" from other errors.
+ */
+const BRANCH_NOT_FOUND_PATTERNS = [
+    "couldn't find remote ref",
+    "pathspec",
+    "did not match any",
+];
+/**
+ * Checks if an error message indicates a branch was not found.
+ */
+function isBranchNotFoundError(message) {
+    return BRANCH_NOT_FOUND_PATTERNS.some((pattern) => message.includes(pattern));
+}
 export class GitOps {
     workDir;
     dryRun;
+    executor;
+    retries;
     constructor(options) {
         this.workDir = options.workDir;
         this.dryRun = options.dryRun ?? false;
+        this.executor = options.executor ?? defaultExecutor;
+        this.retries = options.retries ?? 3;
+    }
+    async exec(command, cwd) {
+        return this.executor.exec(command, cwd ?? this.workDir);
     }
-    exec(command, cwd) {
-        return execSync(command, {
-            cwd: cwd ?? this.workDir,
-            encoding: 'utf-8',
-            stdio: ['pipe', 'pipe', 'pipe'],
-        }).trim();
+    /**
+     * Run a command with retry logic for transient failures.
+     * Used for network operations like clone, fetch, push.
+     */
+    async execWithRetry(command, cwd) {
+        return withRetry(() => this.exec(command, cwd), {
+            retries: this.retries,
+        });
+    }
+    /**
+     * Validates that a file path doesn't escape the workspace directory.
+     * @returns The resolved absolute file path
+     * @throws Error if path traversal is detected
+     */
+    validatePath(fileName) {
+        const filePath = join(this.workDir, fileName);
+        const resolvedPath = resolve(filePath);
+        const resolvedWorkDir = resolve(this.workDir);
+        const relativePath = relative(resolvedWorkDir, resolvedPath);
+        if (relativePath.startsWith("..") || isAbsolute(relativePath)) {
+            throw new Error(`Path traversal detected: ${fileName}`);
+        }
+        return filePath;
     }
     cleanWorkspace() {
         if (existsSync(this.workDir)) {
@@ -22,40 +63,58 @@ export class GitOps {
         }
         mkdirSync(this.workDir, { recursive: true });
     }
-    clone(gitUrl) {
-        this.exec(`git clone ${escapeShellArg(gitUrl)} .`, this.workDir);
+    async clone(gitUrl) {
+        await this.execWithRetry(`git clone ${escapeShellArg(gitUrl)} .`, this.workDir);
     }
-    createBranch(branchName) {
+    async createBranch(branchName) {
         try {
-            // Check if branch exists on remote
-            this.exec(`git fetch origin ${escapeShellArg(branchName)}`, this.workDir);
-            this.exec(`git checkout ${escapeShellArg(branchName)}`, this.workDir);
+            // Check if branch exists on remote (network operation with retry)
+            await this.execWithRetry(`git fetch origin ${escapeShellArg(branchName)}`, this.workDir);
+            // Ensure clean workspace before checkout (defensive - handles edge cases)
+            await this.exec("git reset --hard HEAD", this.workDir);
+            await this.exec("git clean -fd", this.workDir);
+            await this.execWithRetry(`git checkout ${escapeShellArg(branchName)}`, this.workDir);
+            return;
         }
-        catch {
-            // Branch doesn't exist, create it
-            this.exec(`git checkout -b ${escapeShellArg(branchName)}`, this.workDir);
+        catch (error) {
+            // Only proceed to create branch if error indicates branch doesn't exist
+            const message = error instanceof Error ? error.message : String(error);
+            if (!isBranchNotFoundError(message)) {
+                throw new Error(`Failed to fetch/checkout branch '${branchName}': ${message}`);
+            }
+        }
+        // Branch doesn't exist on remote, create it locally
+        try {
+            await this.exec(`git checkout -b ${escapeShellArg(branchName)}`, this.workDir);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error(`Failed to create branch '${branchName}': ${message}`);
         }
     }
     writeFile(fileName, content) {
         if (this.dryRun) {
             return;
         }
-        const filePath = join(this.workDir, fileName);
-        writeFileSync(filePath, content + '\n', 'utf-8');
+        const filePath = this.validatePath(fileName);
+        // Normalize trailing newline - ensure exactly one
+        const normalized = content.endsWith("\n") ? content : content + "\n";
+        writeFileSync(filePath, normalized, "utf-8");
     }
     /**
      * Checks if writing the given content would result in changes.
      * Works in both normal and dry-run modes by comparing content directly.
      */
     wouldChange(fileName, content) {
-        const filePath = join(this.workDir, fileName);
-        const newContent = content + '\n';
+        const filePath = this.validatePath(fileName);
+        // Normalize trailing newline - ensure exactly one
+        const newContent = content.endsWith("\n") ? content : content + "\n";
         if (!existsSync(filePath)) {
             // File doesn't exist, so writing it would be a change
             return true;
         }
         try {
-            const existingContent = readFileSync(filePath, 'utf-8');
+            const existingContent = readFileSync(filePath, "utf-8");
             return existingContent !== newContent;
         }
         catch {
@@ -63,58 +122,82 @@ export class GitOps {
             return true;
         }
     }
-    hasChanges() {
-        const status = this.exec('git status --porcelain', this.workDir);
+    async hasChanges() {
+        const status = await this.exec("git status --porcelain", this.workDir);
         return status.length > 0;
     }
-    commit(message) {
+    async commit(message) {
         if (this.dryRun) {
             return;
         }
-        this.exec('git add -A', this.workDir);
-        this.exec(`git commit -m ${escapeShellArg(message)}`, this.workDir);
+        await this.exec("git add -A", this.workDir);
+        await this.exec(`git commit -m ${escapeShellArg(message)}`, this.workDir);
     }
-    push(branchName) {
+    async push(branchName) {
         if (this.dryRun) {
             return;
         }
-        this.exec(`git push -u origin ${escapeShellArg(branchName)}`, this.workDir);
+        await this.execWithRetry(`git push -u origin ${escapeShellArg(branchName)}`, this.workDir);
     }
-    getDefaultBranch() {
+    async getDefaultBranch() {
         try {
-            // Try to get the default branch from remote
-            const remoteInfo = this.exec('git remote show origin', this.workDir);
+            // Try to get the default branch from remote (network operation with retry)
+            const remoteInfo = await this.execWithRetry("git remote show origin", this.workDir);
             const match = remoteInfo.match(/HEAD branch: (\S+)/);
             if (match) {
-                return { branch: match[1], method: 'remote HEAD' };
+                return { branch: match[1], method: "remote HEAD" };
             }
         }
-        catch {
-            // Fallback methods
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            logger.info(`Debug: git remote show origin failed - ${msg}`);
         }
-        // Try common default branch names
+        // Try common default branch names (local operations, no retry needed)
         try {
-            this.exec('git rev-parse --verify origin/main', this.workDir);
-            return { branch: 'main', method: 'origin/main exists' };
+            await this.exec("git rev-parse --verify origin/main", this.workDir);
+            return { branch: "main", method: "origin/main exists" };
         }
-        catch {
-            // Try master
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            logger.info(`Debug: origin/main check failed - ${msg}`);
         }
         try {
-            this.exec('git rev-parse --verify origin/master', this.workDir);
-            return { branch: 'master', method: 'origin/master exists' };
+            await this.exec("git rev-parse --verify origin/master", this.workDir);
+            return { branch: "master", method: "origin/master exists" };
         }
-        catch {
-            // Default to main
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            logger.info(`Debug: origin/master check failed - ${msg}`);
         }
-        return { branch: 'main', method: 'fallback default' };
+        return { branch: "main", method: "fallback default" };
     }
 }
 export function sanitizeBranchName(fileName) {
     return fileName
         .toLowerCase()
-        .replace(/\.[^.]+$/, '') // Remove extension
-        .replace(/[^a-z0-9-]/g, '-') // Replace non-alphanumeric with dashes
-        .replace(/-+/g, '-') // Collapse multiple dashes
-        .replace(/^-|-$/g, ''); // Remove leading/trailing dashes
+        .replace(/\.[^.]+$/, "") // Remove extension
+        .replace(/[^a-z0-9-]/g, "-") // Replace non-alphanumeric with dashes
+        .replace(/-+/g, "-") // Collapse multiple dashes
+        .replace(/^-|-$/g, ""); // Remove leading/trailing dashes
+}
+/**
+ * Validates a user-provided branch name against git's naming rules.
+ * @throws Error if the branch name is invalid
+ */
+export function validateBranchName(branchName) {
+    if (!branchName || branchName.trim() === "") {
+        throw new Error("Branch name cannot be empty");
+    }
+    if (branchName.startsWith(".") || branchName.startsWith("-")) {
+        throw new Error('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");
+    }
+    if (branchName.endsWith("/") ||
+        branchName.endsWith(".lock") ||
+        branchName.endsWith(".")) {
+        throw new Error("Branch name has invalid ending");
+    }
 }

package/dist/index.d.ts

@@ -1,2 +1,20 @@
 #!/usr/bin/env node
-export {};
+import { ProcessorResult } from "./repository-processor.js";
+import { RepoConfig } from "./config.js";
+import { RepoInfo } from "./repo-detector.js";
+import { ProcessorOptions } from "./repository-processor.js";
+/**
+ * Processor interface for dependency injection in tests.
+ */
+export interface IRepositoryProcessor {
+    process(repoConfig: RepoConfig, repoInfo: RepoInfo, options: ProcessorOptions): Promise<ProcessorResult>;
+}
+/**
+ * Factory function type for creating processors.
+ * Allows dependency injection for testing.
+ */
+export type ProcessorFactory = () => IRepositoryProcessor;
+/**
+ * Default factory that creates a real RepositoryProcessor.
+ */
+export declare const defaultProcessorFactory: ProcessorFactory;

package/dist/index.js

@@ -1,29 +1,31 @@
 #!/usr/bin/env node
-import { program } from 'commander';
-import { resolve, join } from 'node:path';
-import { existsSync } from 'node:fs';
-import { randomUUID } from 'node:crypto';
-import { loadConfig, convertContentToString } from './config.js';
-import { parseGitUrl, getRepoDisplayName } from './repo-detector.js';
-import { GitOps, sanitizeBranchName } from './git-ops.js';
-import { createPR } from './pr-creator.js';
-import { logger } from './logger.js';
+import { program } from "commander";
+import { resolve, join, dirname } from "node:path";
+import { existsSync, readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { loadConfig } from "./config.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"));
+import { parseGitUrl, getRepoDisplayName } from "./repo-detector.js";
+import { sanitizeBranchName, validateBranchName } from "./git-ops.js";
+import { logger } from "./logger.js";
+import { generateWorkspaceName } from "./workspace-utils.js";
+import { RepositoryProcessor, } from "./repository-processor.js";
 /**
- * Generates a unique workspace directory name to avoid collisions
- * when multiple CLI instances run concurrently.
+ * Default factory that creates a real RepositoryProcessor.
  */
-function generateWorkspaceName(index) {
-    const timestamp = Date.now();
-    const uuid = randomUUID().slice(0, 8);
-    return `repo-${timestamp}-${index}-${uuid}`;
-}
+export const defaultProcessorFactory = () => new RepositoryProcessor();
 program
-    .name('json-config-sync')
-    .description('Sync JSON configuration files across multiple repositories')
-    .version('1.0.0')
-    .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')
+    .name("json-config-sync")
+    .description("Sync JSON configuration files across multiple repositories")
+    .version(packageJson.version)
+    .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("-b, --branch <name>", "Override the branch name (default: chore/sync-{filename})")
     .parse();
 const options = program.opts();
 async function main() {
@@ -34,14 +36,22 @@ async function main() {
     }
     console.log(`Loading config from: ${configPath}`);
     if (options.dryRun) {
-        console.log('Running in DRY RUN mode - no changes will be made\n');
+        console.log("Running in DRY RUN mode - no changes will be made\n");
     }
     const config = loadConfig(configPath);
-    const branchName = `chore/sync-${sanitizeBranchName(config.fileName)}`;
+    let branchName;
+    if (options.branch) {
+        validateBranchName(options.branch);
+        branchName = options.branch;
+    }
+    else {
+        branchName = `chore/sync-${sanitizeBranchName(config.fileName)}`;
+    }
     logger.setTotal(config.repos.length);
     console.log(`Found ${config.repos.length} repositories to process`);
     console.log(`Target file: ${config.fileName}`);
     console.log(`Branch: ${branchName}\n`);
+    const processor = defaultProcessorFactory();
     for (let i = 0; i < config.repos.length; i++) {
         const repoConfig = config.repos[i];
         const current = i + 1;
@@ -55,62 +65,24 @@ async function main() {
             continue;
         }
         const repoName = getRepoDisplayName(repoInfo);
-        const workDir = resolve(join(options.workDir ?? './tmp', generateWorkspaceName(i)));
+        const workDir = resolve(join(options.workDir ?? "./tmp", generateWorkspaceName(i)));
         try {
-            logger.progress(current, repoName, 'Processing...');
-            const gitOps = new GitOps({ workDir, dryRun: options.dryRun });
-            // Step 1: Clean workspace
-            logger.info('Cleaning workspace...');
-            gitOps.cleanWorkspace();
-            // Step 2: Clone repo
-            logger.info('Cloning repository...');
-            gitOps.clone(repoInfo.gitUrl);
-            // Step 3: Get default branch for PR base
-            const { branch: baseBranch, method: detectionMethod } = gitOps.getDefaultBranch();
-            logger.info(`Default branch: ${baseBranch} (detected via ${detectionMethod})`);
-            // Step 4: Create/checkout branch
-            logger.info(`Switching to branch: ${branchName}`);
-            gitOps.createBranch(branchName);
-            // Determine if creating or updating (check BEFORE writing)
-            const action = existsSync(join(workDir, config.fileName)) ? 'update' : 'create';
-            // Step 5: Write config file
-            logger.info(`Writing ${config.fileName}...`);
-            const fileContent = convertContentToString(repoConfig.content, config.fileName);
-            // Step 6: Check for changes
-            // In dry-run mode, compare content directly since we don't write the file
-            // In normal mode, write the file first then check git status
-            const wouldHaveChanges = options.dryRun
-                ? gitOps.wouldChange(config.fileName, fileContent)
-                : (() => {
-                    gitOps.writeFile(config.fileName, fileContent);
-                    return gitOps.hasChanges();
-                })();
-            if (!wouldHaveChanges) {
-                logger.skip(current, repoName, 'No changes detected');
-                continue;
-            }
-            // Step 7: Commit
-            logger.info('Committing changes...');
-            gitOps.commit(`chore: sync ${config.fileName}`);
-            // Step 8: Push
-            logger.info('Pushing to remote...');
-            gitOps.push(branchName);
-            // Step 9: Create PR
-            logger.info('Creating pull request...');
-            const prResult = await createPR({
-                repoInfo,
-                branchName,
-                baseBranch,
+            logger.progress(current, repoName, "Processing...");
+            const result = await processor.process(repoConfig, repoInfo, {
                 fileName: config.fileName,
-                action,
+                branchName,
                 workDir,
                 dryRun: options.dryRun,
+                retries: options.retries,
             });
-            if (prResult.success) {
-                logger.success(current, repoName, prResult.url ? `PR: ${prResult.url}` : prResult.message);
+            if (result.skipped) {
+                logger.skip(current, repoName, result.message);
+            }
+            else if (result.success) {
+                logger.success(current, repoName, result.prUrl ? `PR: ${result.prUrl}` : result.message);
             }
             else {
-                logger.error(current, repoName, prResult.message);
+                logger.error(current, repoName, result.message);
             }
         }
         catch (error) {
@@ -124,6 +96,6 @@ async function main() {
     }
 }
 main().catch((error) => {
-    console.error('Fatal error:', error);
+    console.error("Fatal error:", error);
     process.exit(1);
 });

package/dist/logger.d.ts

@@ -1,3 +1,6 @@
+export interface ILogger {
+    info(message: string): void;
+}
 export interface LoggerStats {
     total: number;
     succeeded: number;

package/dist/logger.js

@@ -1,4 +1,4 @@
-import chalk from 'chalk';
+import chalk from "chalk";
 export class Logger {
     stats = {
         total: 0,
@@ -10,26 +10,30 @@ export class Logger {
         this.stats.total = total;
     }
     progress(current, repoName, message) {
-        console.log(chalk.blue(`[${current}/${this.stats.total}]`) + ` ${repoName}: ${message}`);
+        console.log(chalk.blue(`[${current}/${this.stats.total}]`) +
+            ` ${repoName}: ${message}`);
     }
     info(message) {
         console.log(chalk.gray(`    ${message}`));
     }
     success(current, repoName, message) {
         this.stats.succeeded++;
-        console.log(chalk.green(`[${current}/${this.stats.total}] ✓`) + ` ${repoName}: ${message}`);
+        console.log(chalk.green(`[${current}/${this.stats.total}] ✓`) +
+            ` ${repoName}: ${message}`);
     }
     skip(current, repoName, reason) {
         this.stats.skipped++;
-        console.log(chalk.yellow(`[${current}/${this.stats.total}] ⊘`) + ` ${repoName}: Skipped - ${reason}`);
+        console.log(chalk.yellow(`[${current}/${this.stats.total}] ⊘`) +
+            ` ${repoName}: Skipped - ${reason}`);
     }
     error(current, repoName, error) {
         this.stats.failed++;
-        console.log(chalk.red(`[${current}/${this.stats.total}] ✗`) + ` ${repoName}: ${error}`);
+        console.log(chalk.red(`[${current}/${this.stats.total}] ✗`) +
+            ` ${repoName}: ${error}`);
     }
     summary() {
-        console.log('');
-        console.log(chalk.bold('Summary:'));
+        console.log("");
+        console.log(chalk.bold("Summary:"));
         console.log(`  Total:     ${this.stats.total}`);
         console.log(chalk.green(`  Succeeded: ${this.stats.succeeded}`));
         console.log(chalk.yellow(`  Skipped:   ${this.stats.skipped}`));

package/dist/merge.d.ts

@@ -2,7 +2,16 @@
  * Deep merge utilities for JSON configuration objects.
  * Supports configurable array merge strategies via $arrayMerge directive.
  */
-export type ArrayMergeStrategy = 'replace' | 'append' | 'prepend';
+export type ArrayMergeStrategy = "replace" | "append" | "prepend";
+/**
+ * Handler function type for array merge strategies.
+ */
+export type ArrayMergeHandler = (base: unknown[], overlay: unknown[]) => unknown[];
+/**
+ * Strategy map for array merge operations.
+ * Extensible: add new strategies by adding to this map.
+ */
+export declare const arrayMergeStrategies: Map<ArrayMergeStrategy, ArrayMergeHandler>;
 export interface MergeContext {
     arrayStrategies: Map<string, ArrayMergeStrategy>;
     defaultArrayStrategy: ArrayMergeStrategy;

package/dist/merge.js

@@ -2,26 +2,31 @@
  * Deep merge utilities for JSON configuration objects.
  * Supports configurable array merge strategies via $arrayMerge directive.
  */
+/**
+ * Strategy map for array merge operations.
+ * Extensible: add new strategies by adding to this map.
+ */
+export const arrayMergeStrategies = new Map([
+    ["replace", (_base, overlay) => overlay],
+    ["append", (base, overlay) => [...base, ...overlay]],
+    ["prepend", (base, overlay) => [...overlay, ...base]],
+]);
 /**
  * Check if a value is a plain object (not null, not array).
  */
 function isPlainObject(val) {
-    return typeof val === 'object' && val !== null && !Array.isArray(val);
+    return typeof val === "object" && val !== null && !Array.isArray(val);
 }
 /**
  * Merge two arrays based on the specified strategy.
  */
 function mergeArrays(base, overlay, strategy) {
-    switch (strategy) {
-        case 'replace':
-            return overlay;
-        case 'append':
-            return [...base, ...overlay];
-        case 'prepend':
-            return [...overlay, ...base];
-        default:
-            return overlay;
+    const handler = arrayMergeStrategies.get(strategy);
+    if (handler) {
+        return handler(base, overlay);
     }
+    // Fallback to replace for unknown strategies
+    return overlay;
 }
 /**
  * Extract array values from an overlay object that uses the directive syntax:
@@ -33,7 +38,7 @@ function extractArrayFromOverlay(overlay) {
     if (Array.isArray(overlay)) {
         return overlay;
     }
-    if (isPlainObject(overlay) && 'values' in overlay) {
+    if (isPlainObject(overlay) && "values" in overlay) {
         const values = overlay.values;
         if (Array.isArray(values)) {
             return values;
@@ -45,11 +50,11 @@ function extractArrayFromOverlay(overlay) {
  * Get merge strategy from an overlay object's $arrayMerge directive.
  */
 function getStrategyFromOverlay(overlay) {
-    if (isPlainObject(overlay) && '$arrayMerge' in overlay) {
+    if (isPlainObject(overlay) && "$arrayMerge" in overlay) {
         const strategy = overlay.$arrayMerge;
-        if (strategy === 'replace' ||
-            strategy === 'append' ||
-            strategy === 'prepend') {
+        if (strategy === "replace" ||
+            strategy === "append" ||
+            strategy === "prepend") {
             return strategy;
         }
     }
@@ -63,18 +68,18 @@ function getStrategyFromOverlay(overlay) {
  * @param ctx - Merge context with array strategies
  * @param path - Current path for strategy lookup (internal)
  */
-export function deepMerge(base, overlay, ctx, path = '') {
+export function deepMerge(base, overlay, ctx, path = "") {
     const result = { ...base };
     // Check for $arrayMerge directive at this level (applies to child arrays)
     const levelStrategy = getStrategyFromOverlay(overlay);
     for (const [key, overlayValue] of Object.entries(overlay)) {
         // Skip directive keys in output
-        if (key.startsWith('$'))
+        if (key.startsWith("$"))
             continue;
         const currentPath = path ? `${path}.${key}` : key;
         const baseValue = base[key];
         // If overlay is an object with $arrayMerge directive for an array field
-        if (isPlainObject(overlayValue) && '$arrayMerge' in overlayValue) {
+        if (isPlainObject(overlayValue) && "$arrayMerge" in overlayValue) {
             const strategy = getStrategyFromOverlay(overlayValue);
             const overlayArray = extractArrayFromOverlay(overlayValue);
             if (strategy && overlayArray && Array.isArray(baseValue)) {
@@ -94,13 +99,15 @@ export function deepMerge(base, overlay, ctx, path = '') {
         // Both are plain objects - recurse
         if (isPlainObject(baseValue) && isPlainObject(overlayValue)) {
             // Extract $arrayMerge for child paths if present
-            if ('$arrayMerge' in overlayValue) {
+            if ("$arrayMerge" in overlayValue) {
                 const childStrategy = getStrategyFromOverlay(overlayValue);
                 if (childStrategy) {
                     // Apply to all immediate child arrays
                     for (const childKey of Object.keys(overlayValue)) {
-                        if (!childKey.startsWith('$')) {
-                            const childPath = currentPath ? `${currentPath}.${childKey}` : childKey;
+                        if (!childKey.startsWith("$")) {
+                            const childPath = currentPath
+                                ? `${currentPath}.${childKey}`
+                                : childKey;
                             ctx.arrayStrategies.set(childPath, childStrategy);
                         }
                     }
@@ -122,7 +129,7 @@ export function stripMergeDirectives(obj) {
     const result = {};
     for (const [key, value] of Object.entries(obj)) {
         // Skip all $-prefixed keys (reserved for directives)
-        if (key.startsWith('$'))
+        if (key.startsWith("$"))
             continue;
         if (isPlainObject(value)) {
             result[key] = stripMergeDirectives(value);
@@ -139,7 +146,7 @@ export function stripMergeDirectives(obj) {
 /**
  * Create a default merge context.
  */
-export function createMergeContext(defaultStrategy = 'replace') {
+export function createMergeContext(defaultStrategy = "replace") {
     return {
         arrayStrategies: new Map(),
         defaultArrayStrategy: defaultStrategy,

package/dist/pr-creator.d.ts

@@ -1,18 +1,20 @@
-import { RepoInfo } from './repo-detector.js';
-export { escapeShellArg } from './shell-utils.js';
+import { RepoInfo } from "./repo-detector.js";
+export { escapeShellArg } from "./shell-utils.js";
 export interface PROptions {
     repoInfo: RepoInfo;
     branchName: string;
     baseBranch: string;
     fileName: string;
-    action: 'create' | 'update';
+    action: "create" | "update";
     workDir: string;
     dryRun?: boolean;
+    /** Number of retries for API operations (default: 3) */
+    retries?: number;
 }
 export interface PRResult {
     url?: string;
     success: boolean;
     message: string;
 }
-export declare function formatPRBody(fileName: string, action: 'create' | 'update'): string;
+export declare function formatPRBody(fileName: string, action: "create" | "update"): string;
 export declare function createPR(options: PROptions): Promise<PRResult>;