edsger 0.76.0 → 0.78.0

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

@@ -1,613 +0,0 @@
-/**
- * Git Branch Manager
- * Shared utilities for consistent git branch management across all phases
- */
-import { execFileSync, execSync } from 'child_process';
-import * as fs from 'fs';
-import * as path from 'path';
-import { buildCredentialArgs } from './git-push.js';
-import { resolveDefaultBranch } from './github-repo-info.js';
-import { logError, logInfo } from './logger.js';
-/**
- * Get current Git branch name
- */
-export function getCurrentBranch() {
-    try {
-        return execSync('git branch --show-current', { encoding: 'utf-8' }).trim();
-    }
-    catch (error) {
-        throw new Error(`Failed to get current branch: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}
-/**
- * Check if there are uncommitted changes in the working directory
- */
-export function hasUncommittedChanges() {
-    try {
-        const status = execSync('git status --porcelain', { encoding: 'utf-8' });
-        return status.trim().length > 0;
-    }
-    catch (error) {
-        throw new Error(`Failed to check git status: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}
-/**
- * Get list of uncommitted files
- */
-export function getUncommittedFiles() {
-    try {
-        const status = execSync('git status --porcelain', { encoding: 'utf-8' });
-        return status
-            .trim()
-            .split('\n')
-            .filter((line) => line.length > 0)
-            .map((line) => line.trim());
-    }
-    catch (error) {
-        throw new Error(`Failed to get uncommitted files: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}
-/**
- * Reset uncommitted changes in the working directory
- */
-export function resetUncommittedChanges(verbose) {
-    try {
-        if (verbose) {
-            logInfo(`🔄 Resetting uncommitted changes...`);
-        }
-        execSync('git reset --hard HEAD', { encoding: 'utf-8' });
-        execSync('git clean -fd', { encoding: 'utf-8' });
-        if (verbose) {
-            logInfo(`✅ Reset working directory to clean state`);
-        }
-    }
-    catch (error) {
-        throw new Error(`Failed to reset uncommitted changes: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}
-/**
- * Check if rebase is in progress with conflicts
- */
-export function isRebaseInProgress() {
-    try {
-        // Check for .git/rebase-merge or .git/rebase-apply directory
-        const gitDir = execSync('git rev-parse --git-dir', {
-            encoding: 'utf-8',
-        }).trim();
-        const rebaseMerge = path.join(gitDir, 'rebase-merge');
-        const rebaseApply = path.join(gitDir, 'rebase-apply');
-        return fs.existsSync(rebaseMerge) || fs.existsSync(rebaseApply);
-    }
-    catch (_error) {
-        return false;
-    }
-}
-/**
- * Get list of files with merge conflicts
- */
-export function getConflictFiles() {
-    try {
-        const status = execSync('git diff --name-only --diff-filter=U', {
-            encoding: 'utf-8',
-        });
-        return status
-            .trim()
-            .split('\n')
-            .filter((line) => line.length > 0);
-    }
-    catch (_error) {
-        return [];
-    }
-}
-/**
- * Check if there are any merge conflicts
- */
-export function hasConflicts() {
-    return getConflictFiles().length > 0;
-}
-/**
- * Get detailed information about conflict files including their content
- */
-export function getConflictFileInfos() {
-    const conflictFiles = getConflictFiles();
-    const infos = [];
-    for (const filePath of conflictFiles) {
-        try {
-            // Read the file with conflict markers
-            const content = fs.readFileSync(filePath, 'utf-8');
-            // Get our version (current branch)
-            let oursContent = '';
-            try {
-                oursContent = execSync(`git show :2:${filePath}`, {
-                    encoding: 'utf-8',
-                });
-            }
-            catch (_e) {
-                // File might be new on our side
-                oursContent = '';
-            }
-            // Get their version (incoming branch)
-            let theirsContent = '';
-            try {
-                theirsContent = execSync(`git show :3:${filePath}`, {
-                    encoding: 'utf-8',
-                });
-            }
-            catch (_e) {
-                // File might be new on their side
-                theirsContent = '';
-            }
-            infos.push({
-                filePath,
-                content,
-                oursContent,
-                theirsContent,
-            });
-        }
-        catch (_error) {
-            // Skip files we can't read
-            continue;
-        }
-    }
-    return infos;
-}
-/**
- * Write resolved content for a conflict file and stage it
- */
-export function resolveConflictFile(filePath, resolvedContent, verbose) {
-    try {
-        if (verbose) {
-            logInfo(`📝 Writing resolved content for ${filePath}...`);
-        }
-        fs.writeFileSync(filePath, resolvedContent, 'utf-8');
-        execSync(`git add "${filePath}"`, { encoding: 'utf-8', stdio: 'pipe' });
-        if (verbose) {
-            logInfo(`✅ Resolved and staged ${filePath}`);
-        }
-    }
-    catch (error) {
-        throw new Error(`Failed to resolve conflict in ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}
-/**
- * Continue rebase after conflicts are resolved
- */
-export function continueRebase(verbose) {
-    try {
-        if (verbose) {
-            logInfo(`🔄 Continuing rebase...`);
-        }
-        // Use GIT_EDITOR=true to skip the commit message editor
-        execSync('GIT_EDITOR=true git rebase --continue', {
-            encoding: 'utf-8',
-            stdio: verbose ? 'inherit' : 'pipe',
-        });
-        if (verbose) {
-            logInfo(`✅ Rebase continued successfully`);
-        }
-    }
-    catch (error) {
-        throw new Error(`Failed to continue rebase: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}
-/**
- * Abort the current rebase
- */
-export function abortRebase(verbose) {
-    try {
-        if (verbose) {
-            logInfo(`🔄 Aborting rebase...`);
-        }
-        execSync('git rebase --abort', { encoding: 'utf-8', stdio: 'pipe' });
-        if (verbose) {
-            logInfo(`✅ Rebase aborted`);
-        }
-    }
-    catch (_error) {
-        // Ignore errors - rebase might not be in progress
-    }
-}
-/**
- * Check if a Git branch exists locally
- */
-export function branchExists(branch) {
-    try {
-        execSync(`git rev-parse --verify ${branch}`, {
-            encoding: 'utf-8',
-            stdio: 'pipe',
-        });
-        return true;
-    }
-    catch (_error) {
-        return false;
-    }
-}
-/**
- * Check if a remote branch exists
- */
-export function remoteBranchExists(branch, githubToken) {
-    try {
-        // Fetch remote refs first to ensure we have latest info
-        const credArgs = buildCredentialArgs(githubToken);
-        execFileSync('git', [...credArgs, 'fetch', 'origin', '--prune'], {
-            encoding: 'utf-8',
-            stdio: 'pipe',
-        });
-        execSync(`git rev-parse --verify origin/${branch}`, {
-            encoding: 'utf-8',
-            stdio: 'pipe',
-        });
-        return true;
-    }
-    catch (_error) {
-        return false;
-    }
-}
-/**
- * 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 function switchToBranch(branch, verbose, options) {
-    try {
-        if (verbose) {
-            logInfo(`🔄 Switching to branch ${branch}...`);
-        }
-        // Check if branch exists locally
-        const localExists = branchExists(branch);
-        if (localExists) {
-            // Branch exists locally, just switch to it
-            execSync(`git checkout ${branch}`, { encoding: 'utf-8', stdio: 'pipe' });
-        }
-        else if (options?.skipRemoteCheck) {
-            // Skip remote check, just create from current HEAD
-            if (verbose) {
-                logInfo(`   Branch ${branch} doesn't exist, creating it...`);
-            }
-            execSync(`git checkout -b ${branch}`, {
-                encoding: 'utf-8',
-                stdio: 'pipe',
-            });
-        }
-        else {
-            // Default: Check if branch exists on remote before creating locally
-            // This handles multi-clone scenarios where branch was pushed from another clone
-            try {
-                // Fetch to get latest remote refs
-                const switchCredArgs = buildCredentialArgs(options?.githubToken);
-                execFileSync('git', [...switchCredArgs, 'fetch', 'origin'], {
-                    encoding: 'utf-8',
-                    stdio: 'pipe',
-                });
-                // Check if remote branch exists
-                execSync(`git rev-parse --verify origin/${branch}`, {
-                    encoding: 'utf-8',
-                    stdio: 'pipe',
-                });
-                // Remote branch exists, create local tracking branch from it
-                if (verbose) {
-                    logInfo(`   Branch ${branch} found on remote, creating local tracking branch...`);
-                }
-                execSync(`git checkout -b ${branch} --track origin/${branch}`, {
-                    encoding: 'utf-8',
-                    stdio: 'pipe',
-                });
-            }
-            catch (_e) {
-                // Remote branch doesn't exist, create new branch from current HEAD
-                if (verbose) {
-                    logInfo(`   Branch ${branch} doesn't exist locally or remotely, creating new branch...`);
-                }
-                execSync(`git checkout -b ${branch}`, {
-                    encoding: 'utf-8',
-                    stdio: 'pipe',
-                });
-            }
-        }
-        if (verbose) {
-            logInfo(`✅ Switched to ${branch} branch`);
-        }
-    }
-    catch (error) {
-        throw new Error(`Failed to switch to ${branch} branch: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}
-/**
- * Pull latest changes from remote for a specific branch
- */
-export function pullLatestFromBranch(branch, verbose, githubToken) {
-    try {
-        // Check for uncommitted changes and reset if found
-        if (hasUncommittedChanges()) {
-            if (verbose) {
-                logInfo(`⚠️  Found uncommitted changes. Resetting to clean state before pull...`);
-            }
-            resetUncommittedChanges(verbose);
-        }
-        if (verbose) {
-            logInfo(`📥 Pulling latest changes from origin/${branch}...`);
-        }
-        const credArgs = buildCredentialArgs(githubToken);
-        execFileSync('git', [...credArgs, 'pull', 'origin', branch, '--rebase'], {
-            encoding: 'utf-8',
-            stdio: verbose ? 'inherit' : 'pipe',
-        });
-        if (verbose) {
-            logInfo(`✅ Successfully pulled latest changes from origin/${branch}`);
-        }
-    }
-    catch (error) {
-        throw new Error(`Failed to pull latest changes from ${branch}: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}
-/**
- * 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
- */
-// eslint-disable-next-line complexity -- git branch management with rebase, conflict handling, and fallback strategies
-export function switchToIssueBranchAndRebase(issueBranch, baseBranch, verbose, githubToken) {
-    // eslint-disable-next-line no-param-reassign -- assigning default to optional param
-    baseBranch ??= resolveDefaultBranch();
-    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 {
-        // Check for uncommitted changes and reset if found before any git operations
-        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 credArgs = buildCredentialArgs(githubToken);
-        execFileSync('git', [...credArgs, 'fetch', 'origin'], {
-            encoding: 'utf-8',
-            stdio: 'pipe',
-        });
-        // Check if remote issue branch exists
-        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)}`);
-                }
-                // Reset local branch to match remote branch
-                // This ensures we have all commits from the remote (e.g., from another machine)
-                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) {
-            // Remote branch doesn't exist, that's fine - we'll push later
-            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 main
-    if (verbose) {
-        logInfo(`📥 Rebasing ${issueBranch} with origin/${baseBranch}...`);
-    }
-    try {
-        // Check for uncommitted changes and reset if found
-        if (hasUncommittedChanges()) {
-            if (verbose) {
-                logInfo(`⚠️  Found uncommitted changes. Resetting to clean state before rebase...`);
-            }
-            resetUncommittedChanges(verbose);
-        }
-        const rebaseCredArgs = buildCredentialArgs(githubToken);
-        execFileSync('git', [...rebaseCredArgs, 'pull', 'origin', baseBranch, '--rebase'], {
-            encoding: 'utf-8',
-            stdio: verbose ? 'inherit' : 'pipe',
-        });
-        if (verbose) {
-            logInfo(`✅ Successfully rebased ${issueBranch} with origin/${baseBranch}\n`);
-        }
-    }
-    catch (error) {
-        // If rebase fails, try to abort it to leave repo in clean state
-        try {
-            execSync('git rebase --abort', { encoding: 'utf-8', stdio: 'pipe' });
-            if (verbose) {
-                logError(`❌ Rebase failed and was aborted. Repository is in clean state.`);
-            }
-        }
-        catch (_abortError) {
-            // Rebase abort failed or wasn't needed, that's okay
-        }
-        throw new Error(`Failed to rebase ${issueBranch} with ${baseBranch}: ${error instanceof Error ? error.message : String(error)}\n` +
-            `This usually means there are conflicts between your issue branch and main branch.\n` +
-            `Please resolve conflicts manually and try again.`);
-    }
-    return { previousBranch };
-}
-/**
- * Return to main branch after phase completion
- * This should be called at the END of each phase
- */
-export function returnToMainBranch(baseBranch, verbose) {
-    // eslint-disable-next-line no-param-reassign -- assigning default to optional param
-    baseBranch ??= resolveDefaultBranch();
-    const currentBranch = getCurrentBranch();
-    if (currentBranch === baseBranch) {
-        if (verbose) {
-            logInfo(`ℹ️  Already on ${baseBranch} branch`);
-        }
-        return;
-    }
-    if (verbose) {
-        logInfo(`\n🔄 Returning to ${baseBranch} branch...`);
-        logInfo(`   Current branch: ${currentBranch}`);
-    }
-    // Check for uncommitted changes before switching
-    if (hasUncommittedChanges()) {
-        const uncommittedFiles = getUncommittedFiles();
-        if (verbose) {
-            logError(`⚠️  Warning: Uncommitted changes detected before returning to ${baseBranch}:`);
-            uncommittedFiles.forEach((file) => logError(`     ${file}`));
-            logError(`   Resetting uncommitted changes to allow branch switch.`);
-        }
-        // Reset uncommitted changes to allow clean branch switch
-        // The code should already be committed on the issue branch,
-        // so these changes are likely from post-commit operations
-        resetUncommittedChanges(verbose);
-    }
-    switchToBranch(baseBranch, verbose);
-    if (verbose) {
-        logInfo(`✅ Returned to ${baseBranch} branch\n`);
-    }
-}
-/**
- * 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 function preparePhaseGitEnvironment(issueId, baseBranch, verbose) {
-    const issueBranch = `dev/${issueId}`;
-    return prepareCustomBranchGitEnvironment(issueBranch, baseBranch, verbose);
-}
-/**
- * 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 function prepareCustomBranchGitEnvironment(issueBranch, baseBranch, verbose) {
-    // Resolve once so cleanup and rebase agree on the same target branch.
-    const resolvedDefault = resolveDefaultBranch();
-    const resolvedBase = baseBranch ?? resolvedDefault;
-    // Create cleanup function BEFORE any operations that might fail
-    // This ensures cleanup can be called even if switchToIssueBranchAndRebase throws.
-    // We always return to the repo's default branch (e.g. main, master), not
-    // baseBranch — baseBranch may be an intermediate branch in a chained PR.
-    const cleanup = () => {
-        returnToMainBranch(resolvedDefault, verbose);
-    };
-    try {
-        // Switch to issue branch and rebase with base branch
-        switchToIssueBranchAndRebase(issueBranch, resolvedBase, verbose);
-    }
-    catch (error) {
-        // If setup fails, try to cleanup before re-throwing
-        try {
-            cleanup();
-        }
-        catch (cleanupError) {
-            // Cleanup failed, but we still want to throw the original error
-            if (verbose) {
-                logError(`⚠️  Cleanup failed after setup error: ${cleanupError}`);
-            }
-        }
-        // Re-throw the original error
-        throw error;
-    }
-    // Return cleanup function
-    return cleanup;
-}
-// Re-export async operations from separate file for backward compatibility
-export { prepareCustomBranchGitEnvironmentAsync, preparePhaseGitEnvironmentAsync, switchToIssueBranchAndRebaseAsync, syncFeatBranchWithMain, } from './git-branch-manager-async.js';

package/dist/utils/git-push.d.ts

@@ -1,43 +0,0 @@
-/**
- * Shared git push utilities with GitHub App credential helper support.
- *
- * Uses `git -c credential.helper=...` to pass the token securely per-command,
- * matching the pattern established in workspace-manager.ts for clone/fetch.
- * Uses `execFileSync` instead of `execSync` to avoid shell metacharacter injection.
- */
-export interface GitPushOptions {
-    branchName: string;
-    token?: string;
-    verbose?: boolean;
-    cwd?: string;
-}
-export interface GitPushResult {
-    success: boolean;
-    error?: string;
-    method?: 'push-u' | 'push' | 'force-with-lease';
-}
-/**
- * Build git args with optional credential helper prefix.
- * When a token is provided, prepends `-c credential.helper=...` so git
- * authenticates with the GitHub App installation token.
- */
-export declare function buildCredentialArgs(token?: string): string[];
-/**
- * Push a branch to remote with three-level fallback:
- *   1. git push -u origin <branch>
- *   2. git push origin <branch>
- *   3. git push --force-with-lease origin <branch>
- *
- * When `token` is provided, each command uses a credential helper for authentication.
- */
-export declare function gitPush(options: GitPushOptions): GitPushResult;
-/**
- * Force push a branch using --force-with-lease.
- * Used after rebase operations to update the remote branch.
- */
-export declare function gitForcePush(options: GitPushOptions): GitPushResult;
-/**
- * Push the current branch to remote.
- * Resolves the current branch name first, then delegates to gitPush.
- */
-export declare function gitPushCurrentBranch(options: Omit<GitPushOptions, 'branchName'>): GitPushResult;