@aspruyt/xfg 1.0.0

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

@@ -0,0 +1,221 @@
+import { existsSync, writeFileSync, unlinkSync } from "node:fs";
+import { join } from "node:path";
+import { escapeShellArg } from "../shell-utils.js";
+import { isAzureDevOpsRepo } from "../repo-detector.js";
+import { BasePRStrategy, } from "./pr-strategy.js";
+import { logger } from "../logger.js";
+import { withRetry, isPermanentError } from "../retry-utils.js";
+export class AzurePRStrategy extends BasePRStrategy {
+    constructor(executor) {
+        super(executor);
+        this.bodyFilePath = ".pr-description.md";
+    }
+    getOrgUrl(repoInfo) {
+        return `https://dev.azure.com/${encodeURIComponent(repoInfo.organization)}`;
+    }
+    buildPRUrl(repoInfo, prId) {
+        return `https://dev.azure.com/${encodeURIComponent(repoInfo.organization)}/${encodeURIComponent(repoInfo.project)}/_git/${encodeURIComponent(repoInfo.repo)}/pullrequest/${prId}`;
+    }
+    async checkExistingPR(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);
+        const command = `az repos pr list --repository ${escapeShellArg(azureRepoInfo.repo)} --source-branch ${escapeShellArg(branchName)} --target-branch ${escapeShellArg(baseBranch)} --org ${escapeShellArg(orgUrl)} --project ${escapeShellArg(azureRepoInfo.project)} --query "[0].pullRequestId" -o tsv`;
+        try {
+            const existingPRId = await withRetry(() => this.executor.exec(command, workDir), { retries });
+            return existingPRId ? this.buildPRUrl(azureRepoInfo, existingPRId) : null;
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                if (isPermanentError(error)) {
+                    throw error;
+                }
+                const stderr = error.stderr ?? "";
+                if (stderr && !stderr.includes("does not exist")) {
+                    logger.info(`Debug: Azure PR check failed - ${stderr.trim()}`);
+                }
+            }
+            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)) {
+            throw new Error("Expected Azure DevOps repository");
+        }
+        const azureRepoInfo = repoInfo;
+        const orgUrl = this.getOrgUrl(azureRepoInfo);
+        // Write description to temp file to avoid shell escaping issues
+        const descFile = join(workDir, this.bodyFilePath);
+        writeFileSync(descFile, body, "utf-8");
+        // Azure CLI @file syntax: escape the full @path to handle special chars in workDir
+        const command = `az repos pr create --repository ${escapeShellArg(azureRepoInfo.repo)} --source-branch ${escapeShellArg(branchName)} --target-branch ${escapeShellArg(baseBranch)} --title ${escapeShellArg(title)} --description ${escapeShellArg("@" + descFile)} --org ${escapeShellArg(orgUrl)} --project ${escapeShellArg(azureRepoInfo.project)} --query "pullRequestId" -o tsv`;
+        try {
+            const prId = await withRetry(() => this.executor.exec(command, workDir), {
+                retries,
+            });
+            return {
+                url: this.buildPRUrl(azureRepoInfo, prId),
+                success: true,
+                message: "PR created successfully",
+            };
+        }
+        finally {
+            // Clean up temp file - log warning on failure instead of throwing
+            try {
+                if (existsSync(descFile)) {
+                    unlinkSync(descFile);
+                }
+            }
+            catch (cleanupError) {
+                logger.info(`Warning: Failed to clean up temp file ${descFile}: ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}`);
+            }
+        }
+    }
+    /**
+     * Extract PR ID and repo info from Azure DevOps PR URL.
+     */
+    parsePRUrl(prUrl) {
+        // URL format: https://dev.azure.com/{org}/{project}/_git/{repo}/pullrequest/{prId}
+        const match = prUrl.match(/dev\.azure\.com\/([^/]+)\/([^/]+)\/_git\/([^/]+)\/pullrequest\/(\d+)/);
+        if (!match)
+            return null;
+        return {
+            organization: decodeURIComponent(match[1]),
+            project: decodeURIComponent(match[2]),
+            repo: decodeURIComponent(match[3]),
+            prId: match[4],
+        };
+    }
+    async merge(options) {
+        const { prUrl, config, workDir, retries = 3 } = options;
+        // Manual mode: do nothing
+        if (config.mode === "manual") {
+            return {
+                success: true,
+                message: "PR left open for manual review",
+                merged: false,
+            };
+        }
+        // Parse PR URL to extract details
+        const prInfo = this.parsePRUrl(prUrl);
+        if (!prInfo) {
+            return {
+                success: false,
+                message: `Invalid Azure DevOps PR URL: ${prUrl}`,
+                merged: false,
+            };
+        }
+        const orgUrl = `https://dev.azure.com/${encodeURIComponent(prInfo.organization)}`;
+        const squashFlag = config.strategy === "squash" ? "--squash true" : "";
+        const deleteBranchFlag = config.deleteBranch
+            ? "--delete-source-branch true"
+            : "";
+        if (config.mode === "auto") {
+            // Enable auto-complete (no pre-check needed - always available in Azure DevOps)
+            const command = `az repos pr update --id ${escapeShellArg(prInfo.prId)} --auto-complete true ${squashFlag} ${deleteBranchFlag} --org ${escapeShellArg(orgUrl)} --project ${escapeShellArg(prInfo.project)}`.trim();
+            try {
+                await withRetry(() => this.executor.exec(command, workDir), {
+                    retries,
+                });
+                return {
+                    success: true,
+                    message: "Auto-complete enabled. PR will merge when all policies pass.",
+                    merged: false,
+                    autoMergeEnabled: true,
+                };
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                return {
+                    success: false,
+                    message: `Failed to enable auto-complete: ${message}`,
+                    merged: false,
+                };
+            }
+        }
+        if (config.mode === "force") {
+            // Bypass policies and complete the PR
+            const bypassReason = config.bypassReason ?? "Automated config sync via xfg";
+            const command = `az repos pr update --id ${escapeShellArg(prInfo.prId)} --bypass-policy true --bypass-policy-reason ${escapeShellArg(bypassReason)} --status completed ${squashFlag} ${deleteBranchFlag} --org ${escapeShellArg(orgUrl)} --project ${escapeShellArg(prInfo.project)}`.trim();
+            try {
+                await withRetry(() => this.executor.exec(command, workDir), {
+                    retries,
+                });
+                return {
+                    success: true,
+                    message: "PR completed by bypassing policies.",
+                    merged: true,
+                };
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                return {
+                    success: false,
+                    message: `Failed to bypass policies and complete PR: ${message}`,
+                    merged: false,
+                };
+            }
+        }
+        return {
+            success: false,
+            message: `Unknown merge mode: ${config.mode}`,
+            merged: false,
+        };
+    }
+}

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

@@ -0,0 +1,17 @@
+import { GitHubRepoInfo } from "../repo-detector.js";
+import { PRResult } from "../pr-creator.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.
+     */
+    checkAutoMergeEnabled(repoInfo: GitHubRepoInfo, workDir: string, retries?: number): Promise<boolean>;
+    /**
+     * Build merge strategy flag for gh pr merge command.
+     */
+    private getMergeStrategyFlag;
+    merge(options: MergeOptions): Promise<MergeResult>;
+}

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

@@ -0,0 +1,215 @@
+import { existsSync, writeFileSync, unlinkSync } from "node:fs";
+import { join } from "node:path";
+import { escapeShellArg } from "../shell-utils.js";
+import { isGitHubRepo } from "../repo-detector.js";
+import { BasePRStrategy, } from "./pr-strategy.js";
+import { logger } from "../logger.js";
+import { withRetry, isPermanentError } from "../retry-utils.js";
+export class GitHubPRStrategy extends BasePRStrategy {
+    async checkExistingPR(options) {
+        const { repoInfo, branchName, workDir, retries = 3 } = options;
+        if (!isGitHubRepo(repoInfo)) {
+            throw new Error("Expected GitHub repository");
+        }
+        const command = `gh pr list --head ${escapeShellArg(branchName)} --json url --jq '.[0].url'`;
+        try {
+            const existingPR = await withRetry(() => this.executor.exec(command, workDir), { retries });
+            return existingPR || null;
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                // Throw on permanent errors (auth failures, etc.)
+                if (isPermanentError(error)) {
+                    throw error;
+                }
+                // Log unexpected errors for debugging (expected: empty result means no PR)
+                const stderr = error.stderr ?? "";
+                if (stderr && !stderr.includes("no pull requests match")) {
+                    logger.info(`Debug: GitHub PR check failed - ${stderr.trim()}`);
+                }
+            }
+            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)) {
+            throw new Error("Expected GitHub repository");
+        }
+        // Write body to temp file to avoid shell escaping issues
+        const bodyFile = join(workDir, this.bodyFilePath);
+        writeFileSync(bodyFile, body, "utf-8");
+        const command = `gh pr create --title ${escapeShellArg(title)} --body-file ${escapeShellArg(bodyFile)} --base ${escapeShellArg(baseBranch)} --head ${escapeShellArg(branchName)}`;
+        try {
+            const result = await withRetry(() => this.executor.exec(command, workDir), { retries });
+            // Extract URL from output
+            const urlMatch = result.match(/https:\/\/github\.com\/[^\s]+/);
+            return {
+                url: urlMatch?.[0] ?? result,
+                success: true,
+                message: "PR created successfully",
+            };
+        }
+        finally {
+            // Clean up temp file - log warning on failure instead of throwing
+            try {
+                if (existsSync(bodyFile)) {
+                    unlinkSync(bodyFile);
+                }
+            }
+            catch (cleanupError) {
+                logger.info(`Warning: Failed to clean up temp file ${bodyFile}: ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}`);
+            }
+        }
+    }
+    /**
+     * Check if auto-merge is enabled on the repository.
+     */
+    async checkAutoMergeEnabled(repoInfo, workDir, retries = 3) {
+        const command = `gh api repos/${escapeShellArg(repoInfo.owner)}/${escapeShellArg(repoInfo.repo)} --jq '.allow_auto_merge // false'`;
+        try {
+            const result = await withRetry(() => this.executor.exec(command, workDir), { retries });
+            return result.trim() === "true";
+        }
+        catch (error) {
+            // If we can't check, assume auto-merge is not enabled
+            logger.info(`Warning: Could not check auto-merge status: ${error instanceof Error ? error.message : String(error)}`);
+            return false;
+        }
+    }
+    /**
+     * Build merge strategy flag for gh pr merge command.
+     */
+    getMergeStrategyFlag(strategy) {
+        switch (strategy) {
+            case "squash":
+                return "--squash";
+            case "rebase":
+                return "--rebase";
+            case "merge":
+            default:
+                return "--merge";
+        }
+    }
+    async merge(options) {
+        const { prUrl, config, workDir, retries = 3 } = options;
+        // Manual mode: do nothing
+        if (config.mode === "manual") {
+            return {
+                success: true,
+                message: "PR left open for manual review",
+                merged: false,
+            };
+        }
+        const strategyFlag = this.getMergeStrategyFlag(config.strategy);
+        const deleteBranchFlag = config.deleteBranch ? "--delete-branch" : "";
+        if (config.mode === "auto") {
+            // Check if auto-merge is enabled on the repo
+            // Extract owner/repo from PR URL
+            const match = prUrl.match(/github\.com\/([^/]+)\/([^/]+)/);
+            if (match) {
+                const repoInfo = {
+                    type: "github",
+                    gitUrl: prUrl,
+                    owner: match[1],
+                    repo: match[2],
+                };
+                const autoMergeEnabled = await this.checkAutoMergeEnabled(repoInfo, workDir, retries);
+                if (!autoMergeEnabled) {
+                    logger.info(`Warning: Auto-merge not enabled for '${repoInfo.owner}/${repoInfo.repo}'. PR left open for manual review.`);
+                    logger.info(`To enable: gh repo edit ${repoInfo.owner}/${repoInfo.repo} --enable-auto-merge (requires admin)`);
+                    return {
+                        success: true,
+                        message: `Auto-merge not enabled for repository. PR left open for manual review.`,
+                        merged: false,
+                        autoMergeEnabled: false,
+                    };
+                }
+            }
+            // Enable auto-merge
+            const command = `gh pr merge ${escapeShellArg(prUrl)} --auto ${strategyFlag} ${deleteBranchFlag}`.trim();
+            try {
+                await withRetry(() => this.executor.exec(command, workDir), {
+                    retries,
+                });
+                return {
+                    success: true,
+                    message: "Auto-merge enabled. PR will merge when checks pass.",
+                    merged: false,
+                    autoMergeEnabled: true,
+                };
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                return {
+                    success: false,
+                    message: `Failed to enable auto-merge: ${message}`,
+                    merged: false,
+                };
+            }
+        }
+        if (config.mode === "force") {
+            // Force merge using admin privileges
+            const command = `gh pr merge ${escapeShellArg(prUrl)} --admin ${strategyFlag} ${deleteBranchFlag}`.trim();
+            try {
+                await withRetry(() => this.executor.exec(command, workDir), {
+                    retries,
+                });
+                return {
+                    success: true,
+                    message: "PR merged successfully using admin privileges.",
+                    merged: true,
+                };
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                return {
+                    success: false,
+                    message: `Failed to force merge: ${message}`,
+                    merged: false,
+                };
+            }
+        }
+        return {
+            success: false,
+            message: `Unknown merge mode: ${config.mode}`,
+            merged: false,
+        };
+    }
+}

package/dist/strategies/index.d.ts

@@ -0,0 +1,13 @@
+import { RepoInfo } from "../repo-detector.js";
+import type { PRStrategy } 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.
+ * @param repoInfo - Repository information
+ * @param executor - Optional command executor for shell commands
+ */
+export declare function getPRStrategy(repoInfo: RepoInfo, executor?: CommandExecutor): PRStrategy;

package/dist/strategies/index.js

@@ -0,0 +1,22 @@
+import { isGitHubRepo, isAzureDevOpsRepo } from "../repo-detector.js";
+import { GitHubPRStrategy } from "./github-pr-strategy.js";
+import { AzurePRStrategy } from "./azure-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.
+ * @param repoInfo - Repository information
+ * @param executor - Optional command executor for shell commands
+ */
+export function getPRStrategy(repoInfo, executor) {
+    if (isGitHubRepo(repoInfo)) {
+        return new GitHubPRStrategy(executor);
+    }
+    if (isAzureDevOpsRepo(repoInfo)) {
+        return new AzurePRStrategy(executor);
+    }
+    // Type exhaustiveness check - should never reach here
+    const _exhaustive = repoInfo;
+    throw new Error(`Unknown repository type: ${JSON.stringify(_exhaustive)}`);
+}

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

@@ -0,0 +1,112 @@
+import { PRResult } from "../pr-creator.js";
+import { RepoInfo } from "../repo-detector.js";
+import { CommandExecutor } from "../command-executor.js";
+import type { MergeMode, MergeStrategy } from "../config.js";
+export interface PRMergeConfig {
+    mode: MergeMode;
+    strategy?: MergeStrategy;
+    deleteBranch?: boolean;
+    bypassReason?: string;
+}
+export interface MergeResult {
+    success: boolean;
+    message: string;
+    merged?: boolean;
+    autoMergeEnabled?: boolean;
+}
+export interface PRStrategyOptions {
+    repoInfo: RepoInfo;
+    title: string;
+    body: string;
+    branchName: string;
+    baseBranch: string;
+    workDir: string;
+    /** Number of retries for API operations (default: 3) */
+    retries?: number;
+}
+export interface MergeOptions {
+    prUrl: string;
+    config: PRMergeConfig;
+    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).
+ * Use PRWorkflowExecutor for full workflow orchestration with error handling.
+ */
+export interface PRStrategy {
+    /**
+     * Check if a PR already exists for the given branch
+     * @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
+     */
+    create(options: PRStrategyOptions): Promise<PRResult>;
+    /**
+     * Merge or enable auto-merge for a PR
+     * @returns Result with merge status
+     */
+    merge(options: MergeOptions): Promise<MergeResult>;
+    /**
+     * Execute the full PR creation workflow
+     * @deprecated Use PRWorkflowExecutor.execute() for better SRP
+     */
+    execute(options: PRStrategyOptions): Promise<PRResult>;
+}
+export declare abstract class BasePRStrategy implements PRStrategy {
+    protected bodyFilePath: string;
+    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>;
+    /**
+     * Execute the full PR creation workflow:
+     * 1. Check for existing PR
+     * 2. If exists, return it
+     * 3. Otherwise, create new PR
+     *
+     * @deprecated Use PRWorkflowExecutor.execute() for better SRP
+     */
+    execute(options: PRStrategyOptions): Promise<PRResult>;
+}
+/**
+ * Orchestrates the PR creation workflow with error handling.
+ * Follows Single Responsibility Principle by separating workflow orchestration
+ * from platform-specific PR creation logic.
+ *
+ * Workflow:
+ * 1. Check for existing PR on the branch
+ * 2. If exists, return existing PR URL
+ * 3. Otherwise, create new PR
+ * 4. Handle errors and return failure result
+ */
+export declare class PRWorkflowExecutor {
+    private readonly strategy;
+    constructor(strategy: PRStrategy);
+    /**
+     * Execute the full PR creation workflow with error handling.
+     */
+    execute(options: PRStrategyOptions): Promise<PRResult>;
+}

package/dist/strategies/pr-strategy.js

@@ -0,0 +1,60 @@
+import { defaultExecutor } from "../command-executor.js";
+export class BasePRStrategy {
+    bodyFilePath = ".pr-body.md";
+    executor;
+    constructor(executor) {
+        this.executor = executor ?? defaultExecutor;
+    }
+    /**
+     * Execute the full PR creation workflow:
+     * 1. Check for existing PR
+     * 2. If exists, return it
+     * 3. Otherwise, create new PR
+     *
+     * @deprecated Use PRWorkflowExecutor.execute() for better SRP
+     */
+    async execute(options) {
+        const executor = new PRWorkflowExecutor(this);
+        return executor.execute(options);
+    }
+}
+/**
+ * Orchestrates the PR creation workflow with error handling.
+ * Follows Single Responsibility Principle by separating workflow orchestration
+ * from platform-specific PR creation logic.
+ *
+ * Workflow:
+ * 1. Check for existing PR on the branch
+ * 2. If exists, return existing PR URL
+ * 3. Otherwise, create new PR
+ * 4. Handle errors and return failure result
+ */
+export class PRWorkflowExecutor {
+    strategy;
+    constructor(strategy) {
+        this.strategy = strategy;
+    }
+    /**
+     * Execute the full PR creation workflow with error handling.
+     */
+    async execute(options) {
+        try {
+            const existingUrl = await this.strategy.checkExistingPR(options);
+            if (existingUrl) {
+                return {
+                    url: existingUrl,
+                    success: true,
+                    message: `PR already exists: ${existingUrl}`,
+                };
+            }
+            return await this.strategy.create(options);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                success: false,
+                message: `Failed to create PR: ${message}`,
+            };
+        }
+    }
+}

package/dist/workspace-utils.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generates a unique workspace directory name to avoid collisions
+ * when multiple CLI instances run concurrently.
+ */
+export declare function generateWorkspaceName(index: number): string;

package/dist/workspace-utils.js

@@ -0,0 +1,10 @@
+import { randomUUID } from "node:crypto";
+/**
+ * Generates a unique workspace directory name to avoid collisions
+ * when multiple CLI instances run concurrently.
+ */
+export function generateWorkspaceName(index) {
+    const timestamp = Date.now();
+    const uuid = randomUUID().slice(0, 8);
+    return `repo-${timestamp}-${index}-${uuid}`;
+}