edsger 0.76.0 → 0.78.0

package/dist/utils/git-branch-manager-async.js

@@ -1,425 +0,0 @@
-/**
- * Git Branch Manager - Async Operations
- * Async git operations that support automatic conflict resolution via Claude agent.
- * These functions build on the sync operations from git-branch-manager.ts.
- */
-import { Octokit } from '@octokit/rest';
-import { execFileSync, execSync } from 'child_process';
-import { abortRebase, branchExists, getCurrentBranch, hasConflicts, hasUncommittedChanges, isRebaseInProgress, pullLatestFromBranch, resetUncommittedChanges, returnToMainBranch, switchToBranch, } from './git-branch-manager.js';
-import { buildCredentialArgs, gitForcePush } from './git-push.js';
-import { resolveDefaultBranch } from './github-repo-info.js';
-import { logError, logInfo } from './logger.js';
-// eslint-disable-next-line complexity -- git sync with fetch, merge/rebase, and conflict handling
-export async function syncFeatBranchWithMain(opts) {
-    const { featBranch, githubToken, owner, repo, baseBranch = resolveDefaultBranch(), verbose, } = opts;
-    try {
-        const octokit = new Octokit({ auth: githubToken });
-        // Check if feat branch exists
-        if (verbose) {
-            logInfo(`🔍 Checking if ${featBranch} branch exists...`);
-        }
-        try {
-            await octokit.repos.getBranch({
-                owner,
-                repo,
-                branch: featBranch,
-            });
-        }
-        catch (error) {
-            if (error instanceof Error &&
-                'status' in error &&
-                error.status === 404) {
-                if (verbose) {
-                    logInfo(`ℹ️  ${featBranch} branch does not exist, skipping sync`);
-                }
-                return false; // No feat branch yet, no sync needed (no force push required)
-            }
-            throw error;
-        }
-        // Get the latest SHA of the base branch
-        const { data: baseBranchData } = await octokit.repos.getBranch({
-            owner,
-            repo,
-            branch: baseBranch,
-        });
-        const mainSha = baseBranchData.commit.sha;
-        // Get the current SHA of the feat branch
-        const { data: featBranchData } = await octokit.repos.getBranch({
-            owner,
-            repo,
-            branch: featBranch,
-        });
-        const featSha = featBranchData.commit.sha;
-        // Check if feat branch is already up to date
-        if (verbose) {
-            logInfo(`📥 Syncing ${featBranch} with ${baseBranch}...`);
-            logInfo(`   ${baseBranch} SHA: ${mainSha.substring(0, 7)}`);
-            logInfo(`   ${featBranch} SHA: ${featSha.substring(0, 7)}`);
-        }
-        // If already at the same SHA, no need to update
-        if (mainSha === featSha) {
-            if (verbose) {
-                logInfo(`ℹ️  ${featBranch} is already up to date with ${baseBranch}`);
-            }
-            return false; // Return false since no update was needed (no force push required)
-        }
-        // Use git.updateRef to fast-forward feat branch to main's SHA
-        // This avoids creating a merge commit
-        try {
-            await octokit.git.updateRef({
-                owner,
-                repo,
-                ref: `heads/${featBranch}`,
-                sha: mainSha,
-                force: true, // Force update since feat branch may have diverged
-            });
-            if (verbose) {
-                logInfo(`✅ Successfully synced ${featBranch} to ${baseBranch} (${mainSha.substring(0, 7)})`);
-            }
-        }
-        catch (updateError) {
-            // 422 means the ref doesn't exist or other validation error
-            const status = updateError instanceof Error && 'status' in updateError
-                ? updateError.status
-                : 0;
-            if (status === 422 || status === 404) {
-                if (verbose) {
-                    logInfo(`ℹ️  Could not update ${featBranch} ref, skipping sync`);
-                }
-                return false; // Return false since no update occurred (no force push needed)
-            }
-            throw updateError;
-        }
-        return true;
-    }
-    catch (error) {
-        if (verbose) {
-            logError(`⚠️  Failed to sync ${featBranch} with ${baseBranch}: ${error instanceof Error ? error.message : String(error)}`);
-        }
-        // Don't fail the whole process if sync fails, just log warning
-        return false;
-    }
-}
-/**
- * Switch to issue branch and rebase with base branch, with optional automatic conflict resolution
- * This is the async version that supports conflict resolution using Claude agent
- *
- * @param options - Options for the rebase operation
- * @returns Object containing the previous branch name and conflict resolution result
- */
-// eslint-disable-next-line complexity -- async git branch management with rebase, conflict resolution, and recovery
-export async function switchToIssueBranchAndRebaseAsync(options) {
-    const { issueBranch, baseBranch = resolveDefaultBranch(), rebaseTargetBranch, originalBaseBranch, verbose, resolveConflicts = false, conflictResolverConfig, forcePushAfterRebase = false, baseBranchCompleted = false, githubToken, } = options;
-    // Determine the actual target branch for rebase
-    // If rebaseTargetBranch is set (e.g., main), use it; otherwise use baseBranch
-    const actualRebaseTarget = rebaseTargetBranch || baseBranch;
-    const previousBranch = getCurrentBranch();
-    if (verbose) {
-        logInfo(`\n🔄 Preparing issue branch: ${issueBranch}`);
-        logInfo(`   Current branch: ${previousBranch}`);
-    }
-    // If issue branch doesn't exist, we need to create it from base branch
-    if (!branchExists(issueBranch)) {
-        if (verbose) {
-            logInfo(`   Issue branch ${issueBranch} doesn't exist, will create from ${baseBranch}`);
-        }
-        // First, ensure we're on the base branch to create issue branch from it
-        if (previousBranch !== baseBranch) {
-            if (verbose) {
-                logInfo(`   Switching to ${baseBranch} first...`);
-            }
-            switchToBranch(baseBranch, verbose);
-        }
-        // Pull latest base branch before creating issue branch
-        try {
-            if (verbose) {
-                logInfo(`   Pulling latest ${baseBranch}...`);
-            }
-            pullLatestFromBranch(baseBranch, verbose, githubToken);
-        }
-        catch (_error) {
-            if (verbose) {
-                logInfo(`   ⚠️  Could not pull ${baseBranch}, will create branch from local ${baseBranch}`);
-            }
-        }
-    }
-    // Switch to issue branch (will create if doesn't exist)
-    // Default behavior now checks remote first (handles multi-clone scenarios)
-    if (getCurrentBranch() !== issueBranch) {
-        switchToBranch(issueBranch, verbose, { githubToken });
-    }
-    // Sync with remote issue branch if it exists and local branch needs updating
-    // This handles the case where local branch exists but is behind remote
-    try {
-        if (hasUncommittedChanges()) {
-            if (verbose) {
-                logInfo(`⚠️  Found uncommitted changes. Resetting to clean state before sync...`);
-            }
-            resetUncommittedChanges(verbose);
-        }
-        // Fetch to get latest remote state (may have been fetched in switchToBranch, but ensures fresh data)
-        const syncCredArgs = buildCredentialArgs(githubToken);
-        execFileSync('git', [...syncCredArgs, 'fetch', 'origin'], {
-            encoding: 'utf-8',
-            stdio: 'pipe',
-        });
-        try {
-            execSync(`git rev-parse --verify origin/${issueBranch}`, {
-                encoding: 'utf-8',
-                stdio: 'pipe',
-            });
-            // Remote branch exists, check if we need to sync
-            // Get local and remote commit SHAs
-            const localSha = execSync(`git rev-parse ${issueBranch}`, {
-                encoding: 'utf-8',
-                stdio: 'pipe',
-            }).trim();
-            const remoteSha = execSync(`git rev-parse origin/${issueBranch}`, {
-                encoding: 'utf-8',
-                stdio: 'pipe',
-            }).trim();
-            if (localSha !== remoteSha) {
-                // Local and remote differ, reset to remote
-                if (verbose) {
-                    logInfo(`📥 Syncing with remote issue branch origin/${issueBranch}...`);
-                    logInfo(`   Local:  ${localSha.substring(0, 7)}`);
-                    logInfo(`   Remote: ${remoteSha.substring(0, 7)}`);
-                }
-                execSync(`git reset --hard origin/${issueBranch}`, {
-                    encoding: 'utf-8',
-                    stdio: 'pipe',
-                });
-                if (verbose) {
-                    logInfo(`✅ Synced local branch with origin/${issueBranch}`);
-                }
-            }
-            else if (verbose) {
-                logInfo(`✅ Local branch is up to date with origin/${issueBranch}`);
-            }
-        }
-        catch (_e) {
-            if (verbose) {
-                logInfo(`   Remote branch origin/${issueBranch} doesn't exist yet, will create on push`);
-            }
-        }
-    }
-    catch (_error) {
-        if (verbose) {
-            logInfo(`⚠️  Could not sync with remote issue branch, continuing with local branch`);
-        }
-    }
-    // Rebase issue branch with latest target branch
-    if (verbose) {
-        if (originalBaseBranch) {
-            logInfo(`📥 Rebasing ${issueBranch} onto origin/${actualRebaseTarget} (from ${originalBaseBranch})...`);
-        }
-        else {
-            logInfo(`📥 Rebasing ${issueBranch} with origin/${actualRebaseTarget}...`);
-        }
-    }
-    try {
-        if (hasUncommittedChanges()) {
-            if (verbose) {
-                logInfo(`⚠️  Found uncommitted changes. Resetting to clean state before rebase...`);
-            }
-            resetUncommittedChanges(verbose);
-        }
-        // Fetch the target branch first
-        const fetchCredArgs = buildCredentialArgs(githubToken);
-        execFileSync('git', [...fetchCredArgs, 'fetch', 'origin', actualRebaseTarget], {
-            encoding: 'utf-8',
-            stdio: 'pipe',
-        });
-        if (originalBaseBranch) {
-            // When base branch was squash-merged, use --onto to only rebase new commits
-            // This prevents re-applying commits that were already included in the squash
-            // Command: git rebase --onto <new-base> <old-base>
-            // This rebases commits from <old-base>..HEAD onto <new-base>
-            // Also fetch the originalBaseBranch for the --onto reference
-            execFileSync('git', [...fetchCredArgs, 'fetch', 'origin', originalBaseBranch], {
-                encoding: 'utf-8',
-                stdio: 'pipe',
-            });
-            // Check if the original base branch is still an ancestor of HEAD.
-            // If the branch was already rebased in a previous iteration (e.g., code-review
-            // rebased it, then code-refine runs again), the original base branch won't be
-            // an ancestor anymore. In that case, --onto would incorrectly include all commits
-            // (including main's commits that were picked up during the previous rebase),
-            // creating duplicate commits. Fall back to normal rebase instead.
-            let useOnto = true;
-            try {
-                execSync(`git merge-base --is-ancestor origin/${originalBaseBranch} HEAD`, {
-                    encoding: 'utf-8',
-                    stdio: 'pipe',
-                });
-            }
-            catch {
-                // Not an ancestor - branch was already rebased, --onto boundary is invalid
-                useOnto = false;
-                if (verbose) {
-                    logInfo(`   ℹ️  origin/${originalBaseBranch} is not an ancestor of HEAD (branch was previously rebased)`);
-                    logInfo(`   Falling back to normal rebase onto origin/${actualRebaseTarget}`);
-                }
-            }
-            if (useOnto) {
-                if (verbose) {
-                    logInfo(`   Using --onto to rebase only new commits (after ${originalBaseBranch})`);
-                }
-                execSync(`git rebase --onto origin/${actualRebaseTarget} origin/${originalBaseBranch}`, {
-                    encoding: 'utf-8',
-                    stdio: verbose ? 'inherit' : 'pipe',
-                });
-            }
-            else {
-                execSync(`git rebase origin/${actualRebaseTarget}`, {
-                    encoding: 'utf-8',
-                    stdio: verbose ? 'inherit' : 'pipe',
-                });
-            }
-        }
-        else {
-            // Normal rebase
-            execSync(`git rebase origin/${actualRebaseTarget}`, {
-                encoding: 'utf-8',
-                stdio: verbose ? 'inherit' : 'pipe',
-            });
-        }
-        if (verbose) {
-            logInfo(`✅ Successfully rebased ${issueBranch} with origin/${actualRebaseTarget}\n`);
-        }
-        // Force push after rebase to trigger GitHub to recalculate PR diff
-        if (forcePushAfterRebase) {
-            const pushResult = gitForcePush({
-                branchName: issueBranch,
-                token: githubToken,
-                verbose,
-            });
-            if (!pushResult.success && verbose) {
-                logInfo(`⚠️  Could not force push ${issueBranch}: ${pushResult.error}`);
-            }
-        }
-        return { previousBranch };
-    }
-    catch (error) {
-        // Check if there are conflicts that we can try to resolve
-        if (resolveConflicts && isRebaseInProgress() && hasConflicts()) {
-            if (verbose) {
-                logInfo(`\n⚠️  Rebase conflicts detected. Attempting automatic resolution...`);
-            }
-            // Dynamically import the conflict resolver to avoid circular dependencies
-            const { resolveConflictsWithAgent } = await import('./conflict-resolver.js');
-            const result = await resolveConflictsWithAgent({
-                model: conflictResolverConfig?.model,
-                maxTurns: conflictResolverConfig?.maxTurns,
-                verbose,
-                issueBranch,
-                baseBranch,
-                originalBaseBranch,
-                baseBranchCompleted,
-            });
-            if (result.success) {
-                if (verbose) {
-                    logInfo(`✅ Successfully resolved conflicts and rebased ${issueBranch} with origin/${actualRebaseTarget}\n`);
-                }
-                // Force push after rebase to trigger GitHub to recalculate PR diff
-                if (forcePushAfterRebase) {
-                    const pushResult = gitForcePush({
-                        branchName: issueBranch,
-                        token: githubToken,
-                        verbose,
-                    });
-                    if (!pushResult.success && verbose) {
-                        logInfo(`⚠️  Could not force push ${issueBranch}: ${pushResult.error}`);
-                    }
-                }
-                return {
-                    previousBranch,
-                    conflictsResolved: true,
-                    resolvedFiles: result.resolvedFiles,
-                };
-            }
-            // Conflict resolution failed, abort rebase
-            abortRebase(verbose);
-            throw new Error(`Failed to automatically resolve conflicts during rebase ${issueBranch} with ${actualRebaseTarget}.\n` +
-                `${result.error || 'Unknown error'}\n` +
-                `Please resolve conflicts manually and try again.`);
-        }
-        // No conflict resolution attempted or not a conflict error
-        // Abort rebase and throw error
-        abortRebase(verbose);
-        if (verbose) {
-            logError(`❌ Rebase failed and was aborted. Repository is in clean state.`);
-        }
-        throw new Error(`Failed to rebase ${issueBranch} with ${actualRebaseTarget}: ${error instanceof Error ? error.message : String(error)}\n` +
-            `This usually means there are conflicts between your issue branch and base branch.\n` +
-            `Please resolve conflicts manually and try again.`);
-    }
-}
-/**
- * Async version of prepareCustomBranchGitEnvironment with conflict resolution support.
- *
- * Usage:
- *   const cleanup = await prepareCustomBranchGitEnvironmentAsync({
- *     issueBranch: 'feat/123/2-api',
- *     baseBranch: 'feat/123/1-database',
- *     verbose: true,
- *     resolveConflicts: true,
- *   })
- *   try {
- *     // ... phase logic ...
- *   } finally {
- *     cleanup()
- *   }
- *
- * @param options - Options for the git environment preparation
- * @returns Cleanup function that will return to main branch
- */
-export async function prepareCustomBranchGitEnvironmentAsync(options) {
-    const { verbose } = options;
-    const resolvedDefault = resolveDefaultBranch();
-    // Create cleanup function BEFORE any operations that might fail.
-    // Always return to the repo's default branch (main, master, …), not the
-    // baseBranch — baseBranch may be an intermediate branch in a chained PR.
-    const cleanup = () => {
-        returnToMainBranch(resolvedDefault, verbose);
-    };
-    try {
-        const result = await switchToIssueBranchAndRebaseAsync(options);
-        return {
-            cleanup,
-            conflictsResolved: result.conflictsResolved,
-            resolvedFiles: result.resolvedFiles,
-        };
-    }
-    catch (error) {
-        try {
-            cleanup();
-        }
-        catch (cleanupError) {
-            if (verbose) {
-                logError(`⚠️  Cleanup failed after setup error: ${cleanupError}`);
-            }
-        }
-        throw error;
-    }
-}
-/**
- * Async version of preparePhaseGitEnvironment with conflict resolution support.
- *
- * @param issueId - The issue ID (will be used to construct branch name "dev/{issueId}")
- * @param baseBranch - The base branch to rebase from (default: "main")
- * @param verbose - Whether to log verbose output
- * @param resolveConflicts - Whether to automatically resolve conflicts using Claude
- * @param conflictResolverConfig - Configuration for the conflict resolver
- * @returns Cleanup function and conflict resolution info
- */
-export async function preparePhaseGitEnvironmentAsync(issueId, baseBranch, verbose, resolveConflicts, conflictResolverConfig) {
-    const issueBranch = `dev/${issueId}`;
-    return prepareCustomBranchGitEnvironmentAsync({
-        issueBranch,
-        baseBranch,
-        verbose,
-        resolveConflicts,
-        conflictResolverConfig,
-    });
-}

package/dist/utils/git-branch-manager.d.ts

@@ -1,160 +0,0 @@
-/**
- * Git Branch Manager
- * Shared utilities for consistent git branch management across all phases
- */
-/**
- * Conflict resolver function type
- * Takes conflict file info and returns resolved content
- */
-export type ConflictResolver = (conflictFiles: ConflictFileInfo[]) => Promise<Map<string, string>>;
-/**
- * Information about a file with merge conflicts
- */
-export interface ConflictFileInfo {
-    filePath: string;
-    content: string;
-    oursContent: string;
-    theirsContent: string;
-}
-/**
- * Get current Git branch name
- */
-export declare function getCurrentBranch(): string;
-/**
- * Check if there are uncommitted changes in the working directory
- */
-export declare function hasUncommittedChanges(): boolean;
-/**
- * Get list of uncommitted files
- */
-export declare function getUncommittedFiles(): string[];
-/**
- * Reset uncommitted changes in the working directory
- */
-export declare function resetUncommittedChanges(verbose?: boolean): void;
-/**
- * Check if rebase is in progress with conflicts
- */
-export declare function isRebaseInProgress(): boolean;
-/**
- * Get list of files with merge conflicts
- */
-export declare function getConflictFiles(): string[];
-/**
- * Check if there are any merge conflicts
- */
-export declare function hasConflicts(): boolean;
-/**
- * Get detailed information about conflict files including their content
- */
-export declare function getConflictFileInfos(): ConflictFileInfo[];
-/**
- * Write resolved content for a conflict file and stage it
- */
-export declare function resolveConflictFile(filePath: string, resolvedContent: string, verbose?: boolean): void;
-/**
- * Continue rebase after conflicts are resolved
- */
-export declare function continueRebase(verbose?: boolean): void;
-/**
- * Abort the current rebase
- */
-export declare function abortRebase(verbose?: boolean): void;
-/**
- * Check if a Git branch exists locally
- */
-export declare function branchExists(branch: string): boolean;
-/**
- * Check if a remote branch exists
- */
-export declare function remoteBranchExists(branch: string, githubToken?: string): boolean;
-/**
- * Options for switchToBranch
- */
-export interface SwitchToBranchOptions {
-    /**
-     * Skip checking remote for branch existence.
-     * By default, switchToBranch will check remote if branch doesn't exist locally,
-     * and create a tracking branch if found on remote.
-     * Set this to true to skip the remote check (useful for well-known local branches like 'main').
-     */
-    skipRemoteCheck?: boolean;
-    /** GitHub App installation token for authenticated remote operations */
-    githubToken?: string;
-}
-/**
- * Switch to a specific Git branch, creating it if it doesn't exist
- *
- * By default, if the branch doesn't exist locally, it will:
- * 1. Fetch from origin to check if branch exists on remote
- * 2. If found on remote, create a local tracking branch from it
- * 3. If not found on remote, create a new branch from current HEAD
- *
- * This handles multi-clone scenarios where a branch may have been created
- * and pushed from another local clone.
- *
- * @param branch - The branch name to switch to
- * @param verbose - Whether to log verbose output
- * @param options - Additional options for branch switching
- */
-export declare function switchToBranch(branch: string, verbose?: boolean, options?: SwitchToBranchOptions): void;
-/**
- * Pull latest changes from remote for a specific branch
- */
-export declare function pullLatestFromBranch(branch: string, verbose?: boolean, githubToken?: string): void;
-/**
- * Switch to issue branch and rebase with main
- * This should be called at the START of each phase
- *
- * @param issueBranch - The issue branch to switch to (e.g., "dev/issue-id")
- * @param baseBranch - The base branch to rebase from (usually "main")
- * @param verbose - Whether to log verbose output
- * @returns Object containing the previous branch name
- */
-export declare function switchToIssueBranchAndRebase(issueBranch: string, baseBranch?: string, verbose?: boolean, githubToken?: string): {
-    previousBranch: string;
-};
-/**
- * Return to main branch after phase completion
- * This should be called at the END of each phase
- */
-export declare function returnToMainBranch(baseBranch?: string, verbose?: boolean): void;
-/**
- * Full phase lifecycle: switch to issue branch, rebase with main, and return a cleanup function
- * Usage:
- *   const cleanup = preparePhaseGitEnvironment(issueId, baseBranch, verbose)
- *   try {
- *     // ... phase logic ...
- *   } finally {
- *     cleanup()
- *   }
- *
- * IMPORTANT: If rebase fails, this function will throw an error AFTER ensuring the repo
- * is in a clean state (rebase aborted). The caller should still call the cleanup function
- * in a finally block to return to the main branch.
- *
- * @param issueId - The issue ID (will be used to construct branch name "dev/{issueId}")
- * @param baseBranch - The base branch to rebase from (default: "main")
- * @param verbose - Whether to log verbose output
- * @returns Cleanup function that will return to main branch
- */
-export declare function preparePhaseGitEnvironment(issueId: string, baseBranch?: string, verbose?: boolean): () => void;
-/**
- * Full phase lifecycle with custom branch names for branch chaining support.
- * This allows creating a issue branch from another issue branch (not just main).
- *
- * Usage:
- *   const cleanup = prepareCustomBranchGitEnvironment('feat/123/2-api', 'feat/123/1-database', verbose)
- *   try {
- *     // ... phase logic ...
- *   } finally {
- *     cleanup()
- *   }
- *
- * @param issueBranch - The issue branch to switch to (e.g., "feat/123/2-api")
- * @param baseBranch - The base branch to rebase from (e.g., "main" or "feat/123/1-database")
- * @param verbose - Whether to log verbose output
- * @returns Cleanup function that will return to main branch
- */
-export declare function prepareCustomBranchGitEnvironment(issueBranch: string, baseBranch?: string, verbose?: boolean): () => void;
-export { prepareCustomBranchGitEnvironmentAsync, preparePhaseGitEnvironmentAsync, type RebaseWithConflictResolutionOptions, switchToIssueBranchAndRebaseAsync, type SyncFeatBranchOptions, syncFeatBranchWithMain, } from './git-branch-manager-async.js';