@aspruyt/json-config-sync 2.0.3 → 2.1.0

package/dist/repo-detector.js

@@ -1,14 +1,33 @@
+// Type guards
+export function isGitHubRepo(info) {
+    return info.type === "github";
+}
+export function isAzureDevOpsRepo(info) {
+    return info.type === "azure-devops";
+}
+/**
+ * Valid URL patterns for supported repository types.
+ */
+const GITHUB_URL_PATTERNS = [/^git@github\.com:/, /^https?:\/\/github\.com\//];
+const AZURE_DEVOPS_URL_PATTERNS = [
+    /^git@ssh\.dev\.azure\.com:/,
+    /^https?:\/\/dev\.azure\.com\//,
+];
 export function detectRepoType(gitUrl) {
-    // Check for Azure DevOps SSH format: git@ssh.dev.azure.com:...
-    // Use broader pattern to catch malformed Azure URLs
-    if (/^git@ssh\.dev\.azure\.com:/.test(gitUrl)) {
-        return "azure-devops";
+    // Check for Azure DevOps formats
+    for (const pattern of AZURE_DEVOPS_URL_PATTERNS) {
+        if (pattern.test(gitUrl)) {
+            return "azure-devops";
+        }
     }
-    // Check for Azure DevOps HTTPS format: https://dev.azure.com/...
-    if (/^https?:\/\/dev\.azure\.com\//.test(gitUrl)) {
-        return "azure-devops";
+    // Check for GitHub formats
+    for (const pattern of GITHUB_URL_PATTERNS) {
+        if (pattern.test(gitUrl)) {
+            return "github";
+        }
     }
-    return "github";
+    // Throw for unrecognized URL formats
+    throw new Error(`Unrecognized git URL format: ${gitUrl}. Supported formats: GitHub (git@github.com: or https://github.com/) and Azure DevOps (git@ssh.dev.azure.com: or https://dev.azure.com/)`);
 }
 export function parseGitUrl(gitUrl) {
     const type = detectRepoType(gitUrl);

package/dist/repository-processor.d.ts

@@ -0,0 +1,36 @@
+import { RepoConfig } from "./config.js";
+import { RepoInfo } from "./repo-detector.js";
+import { GitOps, GitOpsOptions } from "./git-ops.js";
+import { ILogger } from "./logger.js";
+export interface ProcessorOptions {
+    fileName: string;
+    branchName: string;
+    workDir: string;
+    dryRun?: boolean;
+    /** Number of retries for network operations (default: 3) */
+    retries?: number;
+}
+/**
+ * Factory function type for creating GitOps instances.
+ * Allows dependency injection for testing.
+ */
+export type GitOpsFactory = (options: GitOpsOptions) => GitOps;
+export interface ProcessorResult {
+    success: boolean;
+    repoName: string;
+    message: string;
+    prUrl?: string;
+    skipped?: boolean;
+}
+export declare class RepositoryProcessor {
+    private gitOps;
+    private readonly gitOpsFactory;
+    private readonly log;
+    /**
+     * Creates a new RepositoryProcessor.
+     * @param gitOpsFactory - Optional factory for creating GitOps instances (for testing)
+     * @param log - Optional logger instance (for testing)
+     */
+    constructor(gitOpsFactory?: GitOpsFactory, log?: ILogger);
+    process(repoConfig: RepoConfig, repoInfo: RepoInfo, options: ProcessorOptions): Promise<ProcessorResult>;
+}

package/dist/repository-processor.js

@@ -0,0 +1,106 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { convertContentToString } from "./config.js";
+import { getRepoDisplayName } from "./repo-detector.js";
+import { GitOps } from "./git-ops.js";
+import { createPR } from "./pr-creator.js";
+import { logger } from "./logger.js";
+export class RepositoryProcessor {
+    gitOps = null;
+    gitOpsFactory;
+    log;
+    /**
+     * Creates a new RepositoryProcessor.
+     * @param gitOpsFactory - Optional factory for creating GitOps instances (for testing)
+     * @param log - Optional logger instance (for testing)
+     */
+    constructor(gitOpsFactory, log) {
+        this.gitOpsFactory = gitOpsFactory ?? ((opts) => new GitOps(opts));
+        this.log = log ?? logger;
+    }
+    async process(repoConfig, repoInfo, options) {
+        const repoName = getRepoDisplayName(repoInfo);
+        const { fileName, branchName, workDir, dryRun, retries } = options;
+        this.gitOps = this.gitOpsFactory({ workDir, dryRun, retries });
+        try {
+            // Step 1: Clean workspace
+            this.log.info("Cleaning workspace...");
+            this.gitOps.cleanWorkspace();
+            // Step 2: Clone repo
+            this.log.info("Cloning repository...");
+            await this.gitOps.clone(repoInfo.gitUrl);
+            // 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}`);
+            await this.gitOps.createBranch(branchName);
+            // Step 5: Write config file
+            this.log.info(`Writing ${fileName}...`);
+            const fileContent = convertContentToString(repoConfig.content, fileName);
+            // Step 6: Check for changes and determine action
+            // NOTE: This is NOT a race condition. We intentionally:
+            // 1. Capture action type (create/update) BEFORE writing - for PR title
+            // 2. Check git status AFTER writing - to detect actual content changes
+            // The action type is cosmetic for the PR; hasChanges() determines whether to proceed.
+            // If file exists with identical content: action="update", hasChanges=false -> skip (correct)
+            // If file doesn't exist: action="create", hasChanges=true -> proceed (correct)
+            const filePath = join(workDir, fileName);
+            let action;
+            let wouldHaveChanges;
+            if (dryRun) {
+                action = existsSync(filePath) ? "update" : "create";
+                wouldHaveChanges = this.gitOps.wouldChange(fileName, fileContent);
+            }
+            else {
+                // Capture action and write atomically (in same sync block)
+                action = existsSync(filePath) ? "update" : "create";
+                this.gitOps.writeFile(fileName, fileContent);
+                wouldHaveChanges = await this.gitOps.hasChanges();
+            }
+            if (!wouldHaveChanges) {
+                return {
+                    success: true,
+                    repoName,
+                    message: "No changes detected",
+                    skipped: true,
+                };
+            }
+            // Step 7: Commit
+            this.log.info("Committing changes...");
+            await this.gitOps.commit(`chore: sync ${fileName}`);
+            // Step 8: Push
+            this.log.info("Pushing to remote...");
+            await this.gitOps.push(branchName);
+            // Step 9: Create PR
+            this.log.info("Creating pull request...");
+            const prResult = await createPR({
+                repoInfo,
+                branchName,
+                baseBranch,
+                fileName,
+                action,
+                workDir,
+                dryRun,
+                retries,
+            });
+            return {
+                success: prResult.success,
+                repoName,
+                message: prResult.message,
+                prUrl: prResult.url,
+            };
+        }
+        finally {
+            // Always cleanup workspace on completion or failure (Improvement 3)
+            if (this.gitOps) {
+                try {
+                    this.gitOps.cleanWorkspace();
+                }
+                catch {
+                    // Ignore cleanup errors - best effort
+                }
+            }
+        }
+    }
+}

package/dist/retry-utils.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Default patterns indicating permanent errors that should NOT be retried.
+ * These typically indicate configuration issues, auth failures, or invalid resources.
+ * Export allows customization for different environments.
+ */
+export declare const DEFAULT_PERMANENT_ERROR_PATTERNS: RegExp[];
+/**
+ * Default patterns indicating transient errors that SHOULD be retried.
+ * These typically indicate temporary network or service issues.
+ * Export allows customization for different environments.
+ */
+export declare const DEFAULT_TRANSIENT_ERROR_PATTERNS: RegExp[];
+export interface RetryOptions {
+    /** Maximum number of retries (default: 3) */
+    retries?: number;
+    /** Callback when a retry attempt fails */
+    onRetry?: (error: Error, attempt: number) => void;
+    /** Custom permanent error patterns (defaults to DEFAULT_PERMANENT_ERROR_PATTERNS) */
+    permanentErrorPatterns?: RegExp[];
+    /** Custom transient error patterns (defaults to DEFAULT_TRANSIENT_ERROR_PATTERNS) */
+    transientErrorPatterns?: RegExp[];
+}
+/**
+ * Classifies an error as permanent (should not retry) or transient (should retry).
+ * @param error The error to classify
+ * @param patterns Custom patterns to use (defaults to DEFAULT_PERMANENT_ERROR_PATTERNS)
+ * @returns true if the error is permanent, false if it might be transient
+ */
+export declare function isPermanentError(error: Error, patterns?: RegExp[]): boolean;
+/**
+ * Checks if an error matches known transient patterns.
+ * @param error The error to check
+ * @param patterns Custom patterns to use (defaults to DEFAULT_TRANSIENT_ERROR_PATTERNS)
+ * @returns true if the error appears to be transient
+ */
+export declare function isTransientError(error: Error, patterns?: RegExp[]): boolean;
+/**
+ * Wraps an async operation with retry logic using exponential backoff.
+ * Automatically classifies errors and aborts retries for permanent failures.
+ *
+ * @param fn The async function to run with retry
+ * @param options Retry configuration options
+ * @returns The result of the function if successful
+ * @throws AbortError for permanent failures, or the last error after all retries exhausted
+ */
+export declare function withRetry<T>(fn: () => Promise<T>, options?: RetryOptions): Promise<T>;
+/**
+ * Wraps a synchronous operation in a Promise for use with retry logic.
+ * @param fn The sync function to run
+ * @returns A Promise that resolves/rejects with the sync result
+ */
+export declare function promisify<T>(fn: () => T): Promise<T>;
+export { AbortError } from "p-retry";

package/dist/retry-utils.js

@@ -0,0 +1,143 @@
+import pRetry, { AbortError } from "p-retry";
+import { logger } from "./logger.js";
+/**
+ * Default patterns indicating permanent errors that should NOT be retried.
+ * These typically indicate configuration issues, auth failures, or invalid resources.
+ * Export allows customization for different environments.
+ */
+export const DEFAULT_PERMANENT_ERROR_PATTERNS = [
+    /permission\s*denied/i,
+    /authentication\s*failed/i,
+    /bad\s*credentials/i,
+    /invalid\s*(token|credentials)/i,
+    /unauthorized/i,
+    /401\b/,
+    /403\b/,
+    /404\b/,
+    /not\s*found/i,
+    /does\s*not\s*exist/i,
+    /repository\s*not\s*found/i,
+    /no\s*such\s*(file|directory|remote|ref)/i,
+    /couldn't\s*find\s*remote\s*ref/i,
+    /invalid\s*remote/i,
+    /not\s*a\s*git\s*repository/i,
+    /non-fast-forward/i,
+    /remote\s*rejected/i,
+];
+/**
+ * Default patterns indicating transient errors that SHOULD be retried.
+ * These typically indicate temporary network or service issues.
+ * Export allows customization for different environments.
+ */
+export const DEFAULT_TRANSIENT_ERROR_PATTERNS = [
+    /timed?\s*out/i,
+    /ETIMEDOUT/,
+    /ECONNRESET/,
+    /ECONNREFUSED/,
+    /ENOTFOUND/,
+    /connection\s*(reset|refused|closed)/i,
+    /network\s*(error|unreachable)/i,
+    /rate\s*limit/i,
+    /too\s*many\s*requests/i,
+    /429\b/,
+    /500\b/,
+    /502\b/,
+    /503\b/,
+    /504\b/,
+    /service\s*unavailable/i,
+    /temporarily\s*unavailable/i,
+    /internal\s*server\s*error/i,
+    /temporary\s*(failure|error)/i,
+    /try\s*again/i,
+    /ssh_exchange_identification/i,
+    /could\s*not\s*resolve\s*host/i,
+    /unable\s*to\s*access/i,
+];
+/**
+ * Classifies an error as permanent (should not retry) or transient (should retry).
+ * @param error The error to classify
+ * @param patterns Custom patterns to use (defaults to DEFAULT_PERMANENT_ERROR_PATTERNS)
+ * @returns true if the error is permanent, false if it might be transient
+ */
+export function isPermanentError(error, patterns = DEFAULT_PERMANENT_ERROR_PATTERNS) {
+    const message = error.message;
+    const stderr = error.stderr?.toString() ?? "";
+    const combined = `${message} ${stderr}`;
+    // Check permanent patterns first - these always stop retries
+    for (const pattern of patterns) {
+        if (pattern.test(combined)) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Checks if an error matches known transient patterns.
+ * @param error The error to check
+ * @param patterns Custom patterns to use (defaults to DEFAULT_TRANSIENT_ERROR_PATTERNS)
+ * @returns true if the error appears to be transient
+ */
+export function isTransientError(error, patterns = DEFAULT_TRANSIENT_ERROR_PATTERNS) {
+    const message = error.message;
+    const stderr = error.stderr?.toString() ?? "";
+    const combined = `${message} ${stderr}`;
+    for (const pattern of patterns) {
+        if (pattern.test(combined)) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Wraps an async operation with retry logic using exponential backoff.
+ * Automatically classifies errors and aborts retries for permanent failures.
+ *
+ * @param fn The async function to run with retry
+ * @param options Retry configuration options
+ * @returns The result of the function if successful
+ * @throws AbortError for permanent failures, or the last error after all retries exhausted
+ */
+export async function withRetry(fn, options) {
+    const retries = options?.retries ?? 3;
+    const permanentPatterns = options?.permanentErrorPatterns;
+    return pRetry(async () => {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            if (error instanceof Error &&
+                isPermanentError(error, permanentPatterns)) {
+                // Wrap in AbortError to stop retrying immediately
+                throw new AbortError(error.message);
+            }
+            throw error;
+        }
+    }, {
+        retries,
+        onFailedAttempt: (context) => {
+            // Only log if this isn't the last attempt
+            if (context.retriesLeft > 0) {
+                const msg = context.error.message || "Unknown error";
+                logger.info(`Attempt ${context.attemptNumber}/${retries + 1} failed: ${msg}. Retrying...`);
+                options?.onRetry?.(context.error, context.attemptNumber);
+            }
+        },
+    });
+}
+/**
+ * Wraps a synchronous operation in a Promise for use with retry logic.
+ * @param fn The sync function to run
+ * @returns A Promise that resolves/rejects with the sync result
+ */
+export function promisify(fn) {
+    return new Promise((resolve, reject) => {
+        try {
+            resolve(fn());
+        }
+        catch (error) {
+            reject(error);
+        }
+    });
+}
+// Re-export AbortError for use in custom error handling
+export { AbortError } from "p-retry";

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

@@ -0,0 +1,10 @@
+import { PRResult } from "../pr-creator.js";
+import { BasePRStrategy, PRStrategyOptions } 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>;
+    create(options: PRStrategyOptions): Promise<PRResult>;
+}

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

@@ -0,0 +1,78 @@
+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 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)}`);
+            }
+        }
+    }
+}

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

@@ -0,0 +1,6 @@
+import { PRResult } from "../pr-creator.js";
+import { BasePRStrategy, PRStrategyOptions } from "./pr-strategy.js";
+export declare class GitHubPRStrategy extends BasePRStrategy {
+    checkExistingPR(options: PRStrategyOptions): Promise<string | null>;
+    create(options: PRStrategyOptions): Promise<PRResult>;
+}

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

@@ -0,0 +1,65 @@
+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 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)}`);
+            }
+        }
+    }
+}

package/dist/strategies/index.d.ts

@@ -0,0 +1,12 @@
+import { RepoInfo } from "../repo-detector.js";
+import type { PRStrategy } from "./pr-strategy.js";
+export type { PRStrategy, PRStrategyOptions } 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).
+ */
+export declare function getPRStrategy(repoInfo: RepoInfo): 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.
+ * Note: repoInfo is passed via PRStrategyOptions.execute() rather than constructor
+ * to ensure LSP compliance (all strategies have identical constructors).
+ */
+export function getPRStrategy(repoInfo) {
+    if (isGitHubRepo(repoInfo)) {
+        return new GitHubPRStrategy();
+    }
+    if (isAzureDevOpsRepo(repoInfo)) {
+        return new AzurePRStrategy();
+    }
+    // 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,70 @@
+import { PRResult } from "../pr-creator.js";
+import { RepoInfo } from "../repo-detector.js";
+import { CommandExecutor } from "../command-executor.js";
+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;
+}
+/**
+ * Interface for PR creation strategies (platform-specific implementations).
+ * Strategies focus on platform-specific logic (checkExistingPR, create).
+ * 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>;
+    /**
+     * Create a new PR
+     * @returns Result with URL and status
+     */
+    create(options: PRStrategyOptions): Promise<PRResult>;
+    /**
+     * 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 create(options: PRStrategyOptions): Promise<PRResult>;
+    /**
+     * 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>;
+}