@aspruyt/json-config-sync 3.10.0 → 3.10.3

package/README.md

@@ -540,7 +540,7 @@ repos:
 
 ### Executable Files
 
-Shell scripts (`.sh` files) are automatically marked as executable using `git update-index --chmod=+x`. You can control this behavior:
+Shell scripts (`.sh` files) are automatically marked as executable using `git update-index --add --chmod=+x`. You can control this behavior:
 
 ```yaml
 files:

package/dist/command-executor.js

@@ -18,6 +18,10 @@ export class ShellCommandExecutor {
             if (execError.stderr && typeof execError.stderr !== "string") {
                 execError.stderr = execError.stderr.toString();
             }
+            // Include stderr in error message for better debugging
+            if (execError.stderr && execError.message) {
+                execError.message = `${execError.message}\n${execError.stderr}`;
+            }
             throw error;
         }
     }

package/dist/git-ops.d.ts

@@ -26,6 +26,11 @@ export declare class GitOps {
     private validatePath;
     cleanWorkspace(): void;
     clone(gitUrl: string): Promise<void>;
+    /**
+     * Create a new branch from the current HEAD.
+     * Always creates fresh - existing branches should be cleaned up beforehand
+     * by closing any existing PRs (which deletes the remote branch).
+     */
     createBranch(branchName: string): Promise<void>;
     writeFile(fileName: string, content: string): void;
     /**
@@ -40,7 +45,22 @@ export declare class GitOps {
      */
     wouldChange(fileName: string, content: string): boolean;
     hasChanges(): Promise<boolean>;
-    commit(message: string): Promise<void>;
+    /**
+     * Check if there are staged changes ready to commit.
+     * Uses `git diff --cached --quiet` which exits with 1 if there are staged changes.
+     */
+    hasStagedChanges(): Promise<boolean>;
+    /**
+     * Check if a file exists on a specific branch.
+     * Used for createOnly checks against the base branch (not the working directory).
+     */
+    fileExistsOnBranch(fileName: string, branch: string): Promise<boolean>;
+    /**
+     * Stage all changes and commit with the given message.
+     * Uses --no-verify to skip pre-commit hooks (config sync should always succeed).
+     * @returns true if a commit was made, false if there were no staged changes
+     */
+    commit(message: string): Promise<boolean>;
     push(branchName: string): Promise<void>;
     getDefaultBranch(): Promise<{
         branch: string;

package/dist/git-ops.js

@@ -4,21 +4,6 @@ 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;
@@ -66,24 +51,12 @@ export class GitOps {
     async clone(gitUrl) {
         await this.execWithRetry(`git clone ${escapeShellArg(gitUrl)} .`, this.workDir);
     }
+    /**
+     * Create a new branch from the current HEAD.
+     * Always creates fresh - existing branches should be cleaned up beforehand
+     * by closing any existing PRs (which deletes the remote branch).
+     */
     async createBranch(branchName) {
-        try {
-            // 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 (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);
         }
@@ -115,7 +88,7 @@ export class GitOps {
         const filePath = this.validatePath(fileName);
         // Use relative path from workDir for git command
         const relativePath = relative(this.workDir, filePath);
-        await this.exec(`git update-index --chmod=+x ${escapeShellArg(relativePath)}`, this.workDir);
+        await this.exec(`git update-index --add --chmod=+x ${escapeShellArg(relativePath)}`, this.workDir);
     }
     /**
      * Checks if writing the given content would result in changes.
@@ -142,12 +115,49 @@ export class GitOps {
         const status = await this.exec("git status --porcelain", this.workDir);
         return status.length > 0;
     }
+    /**
+     * Check if there are staged changes ready to commit.
+     * Uses `git diff --cached --quiet` which exits with 1 if there are staged changes.
+     */
+    async hasStagedChanges() {
+        try {
+            await this.exec("git diff --cached --quiet", this.workDir);
+            return false; // Exit code 0 = no staged changes
+        }
+        catch {
+            return true; // Exit code 1 = there are staged changes
+        }
+    }
+    /**
+     * Check if a file exists on a specific branch.
+     * Used for createOnly checks against the base branch (not the working directory).
+     */
+    async fileExistsOnBranch(fileName, branch) {
+        try {
+            await this.exec(`git show ${escapeShellArg(branch)}:${escapeShellArg(fileName)}`, this.workDir);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Stage all changes and commit with the given message.
+     * Uses --no-verify to skip pre-commit hooks (config sync should always succeed).
+     * @returns true if a commit was made, false if there were no staged changes
+     */
     async commit(message) {
         if (this.dryRun) {
-            return;
+            return true;
         }
         await this.exec("git add -A", this.workDir);
-        await this.exec(`git commit -m ${escapeShellArg(message)}`, this.workDir);
+        // Check if there are actually staged changes after git add
+        if (!(await this.hasStagedChanges())) {
+            return false; // No changes to commit
+        }
+        // Use --no-verify to skip pre-commit hooks
+        await this.exec(`git commit --no-verify -m ${escapeShellArg(message)}`, this.workDir);
+        return true;
     }
     async push(branchName) {
         if (this.dryRun) {

package/dist/repository-processor.d.ts

@@ -2,12 +2,15 @@ import { RepoConfig } from "./config.js";
 import { RepoInfo } from "./repo-detector.js";
 import { GitOps, GitOpsOptions } from "./git-ops.js";
 import { ILogger } from "./logger.js";
+import { CommandExecutor } from "./command-executor.js";
 export interface ProcessorOptions {
     branchName: string;
     workDir: string;
     dryRun?: boolean;
     /** Number of retries for network operations (default: 3) */
     retries?: number;
+    /** Command executor for shell commands (for testing) */
+    executor?: CommandExecutor;
 }
 /**
  * Factory function type for creating GitOps instances.

package/dist/repository-processor.js

@@ -5,6 +5,8 @@ import { getRepoDisplayName } from "./repo-detector.js";
 import { GitOps } from "./git-ops.js";
 import { createPR, mergePR } from "./pr-creator.js";
 import { logger } from "./logger.js";
+import { getPRStrategy } from "./strategies/index.js";
+import { defaultExecutor } from "./command-executor.js";
 /**
  * Determines if a file should be marked as executable.
  * .sh files are auto-executable unless explicit executable: false is set.
@@ -35,6 +37,7 @@ export class RepositoryProcessor {
     async process(repoConfig, repoInfo, options) {
         const repoName = getRepoDisplayName(repoInfo);
         const { branchName, workDir, dryRun, retries } = options;
+        const executor = options.executor ?? defaultExecutor;
         this.gitOps = this.gitOpsFactory({ workDir, dryRun, retries });
         try {
             // Step 1: Clean workspace
@@ -46,19 +49,39 @@ export class RepositoryProcessor {
             // Step 3: Get default branch for PR base
             const { branch: baseBranch, method: detectionMethod } = await this.gitOps.getDefaultBranch();
             this.log.info(`Default branch: ${baseBranch} (detected via ${detectionMethod})`);
-            // Step 4: Create/checkout branch
-            this.log.info(`Switching to branch: ${branchName}`);
+            // Step 3.5: Close existing PR if exists (fresh start approach)
+            // This ensures isolated sync attempts - each run starts from clean state
+            if (!dryRun) {
+                this.log.info("Checking for existing PR...");
+                const strategy = getPRStrategy(repoInfo, executor);
+                const closed = await strategy.closeExistingPR({
+                    repoInfo,
+                    branchName,
+                    baseBranch,
+                    workDir,
+                    retries,
+                });
+                if (closed) {
+                    this.log.info("Closed existing PR and deleted branch for fresh sync");
+                }
+            }
+            // Step 4: Create branch (always fresh from base branch)
+            this.log.info(`Creating branch: ${branchName}`);
             await this.gitOps.createBranch(branchName);
             // Step 5: Write all config files and track changes
             const changedFiles = [];
             for (const file of repoConfig.files) {
                 const filePath = join(workDir, file.fileName);
-                const fileExists = existsSync(filePath);
-                // Handle createOnly - skip if file already exists
-                if (file.createOnly && fileExists) {
-                    this.log.info(`Skipping ${file.fileName} (createOnly: already exists)`);
-                    changedFiles.push({ fileName: file.fileName, action: "skip" });
-                    continue;
+                const fileExistsLocal = existsSync(filePath);
+                // Handle createOnly - check against BASE branch, not current working directory
+                // This ensures consistent behavior: createOnly means "only create if doesn't exist on main"
+                if (file.createOnly) {
+                    const existsOnBase = await this.gitOps.fileExistsOnBranch(file.fileName, baseBranch);
+                    if (existsOnBase) {
+                        this.log.info(`Skipping ${file.fileName} (createOnly: exists on ${baseBranch})`);
+                        changedFiles.push({ fileName: file.fileName, action: "skip" });
+                        continue;
+                    }
                 }
                 this.log.info(`Writing ${file.fileName}...`);
                 const fileContent = convertContentToString(file.content, file.fileName, {
@@ -66,7 +89,9 @@ export class RepositoryProcessor {
                     schemaUrl: file.schemaUrl,
                 });
                 // Determine action type (create vs update)
-                const action = fileExists ? "update" : "create";
+                const action = fileExistsLocal
+                    ? "update"
+                    : "create";
                 if (dryRun) {
                     // In dry-run, check if file would change without writing
                     if (this.gitOps.wouldChange(file.fileName, fileContent)) {
@@ -125,9 +150,19 @@ export class RepositoryProcessor {
                 };
             }
             // Step 7: Commit
-            this.log.info("Committing changes...");
+            this.log.info("Staging changes...");
             const commitMessage = this.formatCommitMessage(changedFiles);
-            await this.gitOps.commit(commitMessage);
+            const committed = await this.gitOps.commit(commitMessage);
+            if (!committed) {
+                this.log.info("No staged changes after git add -A, skipping commit");
+                return {
+                    success: true,
+                    repoName,
+                    message: "No changes detected after staging",
+                    skipped: true,
+                };
+            }
+            this.log.info(`Committed: ${commitMessage}`);
             // Step 8: Push
             this.log.info("Pushing to remote...");
             await this.gitOps.push(branchName);

package/dist/strategies/azure-pr-strategy.d.ts

@@ -1,11 +1,12 @@
 import { PRResult } from "../pr-creator.js";
-import { BasePRStrategy, PRStrategyOptions, MergeOptions, MergeResult } from "./pr-strategy.js";
+import { BasePRStrategy, PRStrategyOptions, CloseExistingPROptions, MergeOptions, MergeResult } from "./pr-strategy.js";
 import { CommandExecutor } from "../command-executor.js";
 export declare class AzurePRStrategy extends BasePRStrategy {
     constructor(executor?: CommandExecutor);
     private getOrgUrl;
     private buildPRUrl;
     checkExistingPR(options: PRStrategyOptions): Promise<string | null>;
+    closeExistingPR(options: CloseExistingPROptions): Promise<boolean>;
     create(options: PRStrategyOptions): Promise<PRResult>;
     /**
      * Extract PR ID and repo info from Azure DevOps PR URL.

package/dist/strategies/azure-pr-strategy.js

@@ -41,6 +41,58 @@ export class AzurePRStrategy extends BasePRStrategy {
             return null;
         }
     }
+    async closeExistingPR(options) {
+        const { repoInfo, branchName, baseBranch, workDir, retries = 3 } = options;
+        if (!isAzureDevOpsRepo(repoInfo)) {
+            throw new Error("Expected Azure DevOps repository");
+        }
+        const azureRepoInfo = repoInfo;
+        const orgUrl = this.getOrgUrl(azureRepoInfo);
+        // First check if there's an existing PR
+        const existingUrl = await this.checkExistingPR({
+            repoInfo,
+            branchName,
+            baseBranch,
+            workDir,
+            retries,
+            title: "", // Not used for check
+            body: "", // Not used for check
+        });
+        if (!existingUrl) {
+            return false;
+        }
+        // Extract PR ID from URL
+        const prInfo = this.parsePRUrl(existingUrl);
+        if (!prInfo) {
+            logger.info(`Warning: Could not parse PR URL: ${existingUrl}`);
+            return false;
+        }
+        // Abandon the PR (Azure DevOps equivalent of closing)
+        const abandonCommand = `az repos pr update --id ${escapeShellArg(prInfo.prId)} --status abandoned --org ${escapeShellArg(orgUrl)} --project ${escapeShellArg(prInfo.project)}`;
+        try {
+            await withRetry(() => this.executor.exec(abandonCommand, workDir), {
+                retries,
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            logger.info(`Warning: Failed to abandon PR #${prInfo.prId}: ${message}`);
+            return false;
+        }
+        // Delete the source branch
+        const deleteBranchCommand = `az repos ref delete --name refs/heads/${escapeShellArg(branchName)} --repository ${escapeShellArg(azureRepoInfo.repo)} --org ${escapeShellArg(orgUrl)} --project ${escapeShellArg(azureRepoInfo.project)}`;
+        try {
+            await withRetry(() => this.executor.exec(deleteBranchCommand, workDir), {
+                retries,
+            });
+        }
+        catch (error) {
+            // Branch deletion failure is not critical - PR is already abandoned
+            const message = error instanceof Error ? error.message : String(error);
+            logger.info(`Warning: Failed to delete branch ${branchName}: ${message}`);
+        }
+        return true;
+    }
     async create(options) {
         const { repoInfo, title, body, branchName, baseBranch, workDir, retries = 3, } = options;
         if (!isAzureDevOpsRepo(repoInfo)) {

package/dist/strategies/github-pr-strategy.d.ts

@@ -1,8 +1,9 @@
 import { GitHubRepoInfo } from "../repo-detector.js";
 import { PRResult } from "../pr-creator.js";
-import { BasePRStrategy, PRStrategyOptions, MergeOptions, MergeResult } from "./pr-strategy.js";
+import { BasePRStrategy, PRStrategyOptions, CloseExistingPROptions, MergeOptions, MergeResult } from "./pr-strategy.js";
 export declare class GitHubPRStrategy extends BasePRStrategy {
     checkExistingPR(options: PRStrategyOptions): Promise<string | null>;
+    closeExistingPR(options: CloseExistingPROptions): Promise<boolean>;
     create(options: PRStrategyOptions): Promise<PRResult>;
     /**
      * Check if auto-merge is enabled on the repository.

package/dist/strategies/github-pr-strategy.js

@@ -31,6 +31,42 @@ export class GitHubPRStrategy extends BasePRStrategy {
             return null;
         }
     }
+    async closeExistingPR(options) {
+        const { repoInfo, branchName, baseBranch, workDir, retries = 3 } = options;
+        if (!isGitHubRepo(repoInfo)) {
+            throw new Error("Expected GitHub repository");
+        }
+        // First check if there's an existing PR
+        const existingUrl = await this.checkExistingPR({
+            repoInfo,
+            branchName,
+            baseBranch,
+            workDir,
+            retries,
+            title: "", // Not used for check
+            body: "", // Not used for check
+        });
+        if (!existingUrl) {
+            return false;
+        }
+        // Extract PR number from URL
+        const prNumber = existingUrl.match(/\/pull\/(\d+)/)?.[1];
+        if (!prNumber) {
+            logger.info(`Warning: Could not extract PR number from URL: ${existingUrl}`);
+            return false;
+        }
+        // Close the PR and delete the branch
+        const command = `gh pr close ${escapeShellArg(prNumber)} --repo ${escapeShellArg(repoInfo.owner)}/${escapeShellArg(repoInfo.repo)} --delete-branch`;
+        try {
+            await withRetry(() => this.executor.exec(command, workDir), { retries });
+            return true;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            logger.info(`Warning: Failed to close existing PR #${prNumber}: ${message}`);
+            return false;
+        }
+    }
     async create(options) {
         const { repoInfo, title, body, branchName, baseBranch, workDir, retries = 3, } = options;
         if (!isGitHubRepo(repoInfo)) {

package/dist/strategies/index.d.ts

@@ -1,12 +1,13 @@
 import { RepoInfo } from "../repo-detector.js";
 import type { PRStrategy } from "./pr-strategy.js";
-export type { PRStrategy, PRStrategyOptions, PRMergeConfig, MergeOptions, MergeResult, } from "./pr-strategy.js";
+import { CommandExecutor } from "../command-executor.js";
+export type { PRStrategy, PRStrategyOptions, CloseExistingPROptions, PRMergeConfig, MergeOptions, MergeResult, } from "./pr-strategy.js";
 export { BasePRStrategy, PRWorkflowExecutor } from "./pr-strategy.js";
 export { GitHubPRStrategy } from "./github-pr-strategy.js";
 export { AzurePRStrategy } from "./azure-pr-strategy.js";
 /**
  * Factory function to get the appropriate PR strategy for a repository.
- * Note: repoInfo is passed via PRStrategyOptions.execute() rather than constructor
- * to ensure LSP compliance (all strategies have identical constructors).
+ * @param repoInfo - Repository information
+ * @param executor - Optional command executor for shell commands
  */
-export declare function getPRStrategy(repoInfo: RepoInfo): PRStrategy;
+export declare function getPRStrategy(repoInfo: RepoInfo, executor?: CommandExecutor): PRStrategy;

package/dist/strategies/index.js

@@ -6,15 +6,15 @@ export { GitHubPRStrategy } from "./github-pr-strategy.js";
 export { AzurePRStrategy } from "./azure-pr-strategy.js";
 /**
  * Factory function to get the appropriate PR strategy for a repository.
- * Note: repoInfo is passed via PRStrategyOptions.execute() rather than constructor
- * to ensure LSP compliance (all strategies have identical constructors).
+ * @param repoInfo - Repository information
+ * @param executor - Optional command executor for shell commands
  */
-export function getPRStrategy(repoInfo) {
+export function getPRStrategy(repoInfo, executor) {
     if (isGitHubRepo(repoInfo)) {
-        return new GitHubPRStrategy();
+        return new GitHubPRStrategy(executor);
     }
     if (isAzureDevOpsRepo(repoInfo)) {
-        return new AzurePRStrategy();
+        return new AzurePRStrategy(executor);
     }
     // Type exhaustiveness check - should never reach here
     const _exhaustive = repoInfo;

package/dist/strategies/pr-strategy.d.ts

@@ -30,6 +30,16 @@ export interface MergeOptions {
     workDir: string;
     retries?: number;
 }
+/**
+ * Options for closing an existing PR.
+ */
+export interface CloseExistingPROptions {
+    repoInfo: RepoInfo;
+    branchName: string;
+    baseBranch: string;
+    workDir: string;
+    retries?: number;
+}
 /**
  * Interface for PR creation strategies (platform-specific implementations).
  * Strategies focus on platform-specific logic (checkExistingPR, create, merge).
@@ -41,6 +51,12 @@ export interface PRStrategy {
      * @returns PR URL if exists, null otherwise
      */
     checkExistingPR(options: PRStrategyOptions): Promise<string | null>;
+    /**
+     * Close an existing PR and delete its branch.
+     * Used for fresh start approach - always create new PR from clean state.
+     * @returns true if PR was closed, false if no PR existed
+     */
+    closeExistingPR(options: CloseExistingPROptions): Promise<boolean>;
     /**
      * Create a new PR
      * @returns Result with URL and status
@@ -62,6 +78,7 @@ export declare abstract class BasePRStrategy implements PRStrategy {
     protected executor: CommandExecutor;
     constructor(executor?: CommandExecutor);
     abstract checkExistingPR(options: PRStrategyOptions): Promise<string | null>;
+    abstract closeExistingPR(options: CloseExistingPROptions): Promise<boolean>;
     abstract create(options: PRStrategyOptions): Promise<PRResult>;
     abstract merge(options: MergeOptions): Promise<MergeResult>;
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aspruyt/json-config-sync",
-  "version": "3.10.0",
+  "version": "3.10.3",
   "description": "CLI tool to sync JSON or YAML configuration files across multiple GitHub and Azure DevOps repositories",
   "type": "module",
   "main": "dist/index.js",