edsger 0.19.14 → 0.19.16

package/dist/phases/code-refine/index.js

@@ -9,7 +9,7 @@ import { execSync } from 'child_process';
 import { fetchCodeRefineContext, } from './context.js';
 import { getFeedbacksForPhase, formatFeedbacksForContext, } from '../../services/feedbacks.js';
 import { createSystemPrompt, createCodeRefinePrompt } from './prompts.js';
-import { preparePhaseGitEnvironment, prepareCustomBranchGitEnvironment, hasUncommittedChanges, getUncommittedFiles, } from '../../utils/git-branch-manager.js';
+import { preparePhaseGitEnvironmentAsync, prepareCustomBranchGitEnvironmentAsync, hasUncommittedChanges, getUncommittedFiles, } from '../../utils/git-branch-manager.js';
 import { getFeature } from '../../api/features/get-feature.js';
 import { getBranches, getBaseBranchInfo, updateBranch, } from '../../services/branches.js';
 import { verifyAndResolveComments, } from '../code-refine-verification/index.js';
@@ -76,6 +76,7 @@ export const refineCodeFromPRFeedback = async (options, config) => {
     let currentBranch = null;
     let allBranches = [];
     let baseBranchForRebase = 'main'; // Default base branch for rebase
+    let originalBaseBranchForRebase; // For --onto when base was squash-merged
     try {
         // Get all branches to determine base branch info
         allBranches = await getBranches({ featureId, verbose });
@@ -94,12 +95,17 @@ export const refineCodeFromPRFeedback = async (options, config) => {
             // - Base branch merged: returns feat branch (dev/xxx -> feat/xxx)
             // - Base branch not merged: returns dev branch
             baseBranchForRebase = baseBranchInfo.baseBranch;
+            // When base branch is merged (squash merge), we need originalBaseBranch for --onto
+            originalBaseBranchForRebase = baseBranchInfo.originalBaseBranch;
             if (verbose) {
                 if (!currentBranch.base_branch_id) {
                     // No base branch - first branch in chain
                 }
                 else if (baseBranchInfo.baseBranchMerged) {
                     logInfo(`   Base branch is merged, will rebase from feat branch: ${baseBranchForRebase}`);
+                    if (originalBaseBranchForRebase) {
+                        logInfo(`   Using --onto from original base: ${originalBaseBranchForRebase}`);
+                    }
                 }
                 else {
                     logInfo(`   Will rebase from base branch: ${baseBranchForRebase}`);
@@ -136,9 +142,24 @@ export const refineCodeFromPRFeedback = async (options, config) => {
         }
     }
     // Prepare git environment: switch to the appropriate branch and rebase from correct base
-    const cleanupGit = currentBranch
-        ? prepareCustomBranchGitEnvironment(branchName, baseBranchForRebase, verbose)
-        : preparePhaseGitEnvironment(featureId, 'main', verbose);
+    // Use async version with automatic conflict resolution
+    const gitEnvResult = currentBranch
+        ? await prepareCustomBranchGitEnvironmentAsync({
+            featureBranch: branchName,
+            baseBranch: baseBranchForRebase,
+            originalBaseBranch: originalBaseBranchForRebase,
+            verbose,
+            resolveConflicts: true,
+            conflictResolverConfig: {
+                model: config.claude.model || 'sonnet',
+            },
+        })
+        : await preparePhaseGitEnvironmentAsync(featureId, 'main', verbose, true, { model: config.claude.model || 'sonnet' });
+    const cleanupGit = gitEnvResult.cleanup;
+    // Log if conflicts were automatically resolved
+    if (gitEnvResult.conflictsResolved && verbose) {
+        logInfo(`🔧 Automatically resolved ${gitEnvResult.resolvedFiles?.length || 0} conflict(s) during rebase`);
+    }
     try {
         // Fetch initial code refine context (PR reviews and comments)
         if (verbose) {

package/dist/phases/code-review/index.js

@@ -7,7 +7,7 @@ import { logInfo, logError } from '../../utils/logger.js';
 import { Octokit } from '@octokit/rest';
 import { fetchCodeReviewContext, formatContextForPrompt, } from './context.js';
 import { getFeedbacksForPhase, formatFeedbacksForContext, } from '../../services/feedbacks.js';
-import { preparePhaseGitEnvironment, prepareCustomBranchGitEnvironment, } from '../../utils/git-branch-manager.js';
+import { preparePhaseGitEnvironmentAsync, prepareCustomBranchGitEnvironmentAsync, } from '../../utils/git-branch-manager.js';
 import { getBranches, getBaseBranchInfo, updateBranch, } from '../../services/branches.js';
 import { getFeature } from '../../api/features/get-feature.js';
 function userMessage(content) {
@@ -128,6 +128,7 @@ export const reviewPullRequest = async (options, config) => {
     let currentBranch = null;
     let allBranches = [];
     let baseBranchForRebase = 'main'; // Default base branch for rebase
+    let originalBaseBranchForRebase; // For --onto when base was squash-merged
     try {
         // Get all branches to determine base branch info
         allBranches = await getBranches({ featureId, verbose });
@@ -147,12 +148,17 @@ export const reviewPullRequest = async (options, config) => {
             // - Base branch merged: returns feat branch (dev/xxx -> feat/xxx)
             // - Base branch not merged: returns dev branch
             baseBranchForRebase = baseBranchInfo.baseBranch;
+            // When base branch is merged (squash merge), we need originalBaseBranch for --onto
+            originalBaseBranchForRebase = baseBranchInfo.originalBaseBranch;
             if (verbose) {
                 if (!currentBranch.base_branch_id) {
                     // No base branch - first branch in chain
                 }
                 else if (baseBranchInfo.baseBranchMerged) {
                     logInfo(`   Base branch is merged, will rebase from feat branch: ${baseBranchForRebase}`);
+                    if (originalBaseBranchForRebase) {
+                        logInfo(`   Using --onto from original base: ${originalBaseBranchForRebase}`);
+                    }
                 }
                 else {
                     logInfo(`   Will rebase from base branch: ${baseBranchForRebase}`);
@@ -189,9 +195,24 @@ export const reviewPullRequest = async (options, config) => {
         }
     }
     // Prepare git environment: switch to the appropriate branch and rebase from correct base
-    const cleanupGit = currentBranch
-        ? prepareCustomBranchGitEnvironment(branchName, baseBranchForRebase, verbose)
-        : preparePhaseGitEnvironment(featureId, 'main', verbose);
+    // Use async version with automatic conflict resolution
+    const gitEnvResult = currentBranch
+        ? await prepareCustomBranchGitEnvironmentAsync({
+            featureBranch: branchName,
+            baseBranch: baseBranchForRebase,
+            originalBaseBranch: originalBaseBranchForRebase,
+            verbose,
+            resolveConflicts: true,
+            conflictResolverConfig: {
+                model: config.claude.model || 'sonnet',
+            },
+        })
+        : await preparePhaseGitEnvironmentAsync(featureId, 'main', verbose, true, { model: config.claude.model || 'sonnet' });
+    const cleanupGit = gitEnvResult.cleanup;
+    // Log if conflicts were automatically resolved
+    if (gitEnvResult.conflictsResolved && verbose) {
+        logInfo(`🔧 Automatically resolved ${gitEnvResult.resolvedFiles?.length || 0} conflict(s) during rebase`);
+    }
     try {
         // Fetch code review context (PR data, files, commits)
         if (verbose) {

package/dist/services/branches.d.ts

@@ -12,7 +12,7 @@ export interface Branch {
     base_branch_id: string | null;
     pull_request_url: string | null;
     pull_request_number: number | null;
-    status: 'pending' | 'in_progress' | 'ready_for_review' | 'reviewed' | 'refined' | 'merged' | 'closed';
+    status: 'pending' | 'in_progress' | 'ready_for_review' | 'reviewed' | 'refined' | 'merged' | 'completed' | 'closed';
     created_at: string;
     updated_at: string;
 }
@@ -56,19 +56,28 @@ export declare function hasMultipleBranches(options: PipelinePhaseOptions): Prom
  */
 export declare function getNextPendingBranch(options: PipelinePhaseOptions): Promise<Branch | null>;
 /**
- * Check if all branches are completed
+ * Check if all branches are completed (feat merged to main)
  */
 export declare function allBranchesCompleted(options: PipelinePhaseOptions): Promise<boolean>;
 /**
  * Get the base branch information for a branch.
  * Returns:
  * - If base_branch_id is null: use main (first branch in chain)
+ * - If base_branch_id is set and that branch is completed: use main
+ *   (completed means feat merged to main)
  * - If base_branch_id is set and that branch is merged: use base branch's feat branch
  *   (merged means dev merged to feat, not to main)
  * - If base_branch_id is set and that branch is not merged: use base branch's dev branch
+ *
+ * When base branch is merged/completed (squash merge), we need to use `git rebase --onto` to
+ * correctly rebase only the new commits. This function returns both the new base
+ * and the original base for this purpose:
+ * - completed: baseBranch=main, originalBaseBranch=feat/xxx
+ * - merged: baseBranch=feat/xxx, originalBaseBranch=dev/xxx
  */
 export declare function getBaseBranchInfo(branch: Branch, allBranches: Branch[], mainBranch?: string): Promise<{
     baseBranch: string;
+    originalBaseBranch?: string;
     needsRebase: boolean;
     baseBranchMerged: boolean;
 }>;

package/dist/services/branches.js

@@ -97,6 +97,8 @@ export function formatBranchesForContext(branches) {
     }
     const getStatusEmoji = (status) => {
         switch (status) {
+            case 'completed':
+                return '🏁';
             case 'merged':
                 return '✅';
             case 'refined':
@@ -148,21 +150,29 @@ export async function getNextPendingBranch(options) {
     return branches.find((b) => b.status === 'pending') || null;
 }
 /**
- * Check if all branches are completed
+ * Check if all branches are completed (feat merged to main)
  */
 export async function allBranchesCompleted(options) {
     const branches = await getBranches(options);
     if (branches.length === 0)
         return true;
-    return branches.every((b) => b.status === 'merged' || b.status === 'closed');
+    return branches.every((b) => b.status === 'completed' || b.status === 'merged' || b.status === 'closed');
 }
 /**
  * Get the base branch information for a branch.
  * Returns:
  * - If base_branch_id is null: use main (first branch in chain)
+ * - If base_branch_id is set and that branch is completed: use main
+ *   (completed means feat merged to main)
  * - If base_branch_id is set and that branch is merged: use base branch's feat branch
  *   (merged means dev merged to feat, not to main)
  * - If base_branch_id is set and that branch is not merged: use base branch's dev branch
+ *
+ * When base branch is merged/completed (squash merge), we need to use `git rebase --onto` to
+ * correctly rebase only the new commits. This function returns both the new base
+ * and the original base for this purpose:
+ * - completed: baseBranch=main, originalBaseBranch=feat/xxx
+ * - merged: baseBranch=feat/xxx, originalBaseBranch=dev/xxx
  */
 export async function getBaseBranchInfo(branch, allBranches, mainBranch = 'main') {
     // No base branch - start from main (first branch in chain)
@@ -183,6 +193,25 @@ export async function getBaseBranchInfo(branch, allBranches, mainBranch = 'main'
             baseBranchMerged: true,
         };
     }
+    // Check if base branch is completed (feat merged to main)
+    if (baseBranch.status === 'completed') {
+        // Base branch's feat is merged to main - rebase directly from main
+        // Use feat branch as originalBaseBranch for --onto
+        if (!baseBranch.branch_name) {
+            return {
+                baseBranch: mainBranch,
+                needsRebase: false,
+                baseBranchMerged: true,
+            };
+        }
+        const featBranchName = baseBranch.branch_name.replace(/^dev\//, 'feat/');
+        return {
+            baseBranch: mainBranch,
+            originalBaseBranch: featBranchName, // Use feat branch for --onto
+            needsRebase: true,
+            baseBranchMerged: true,
+        };
+    }
     // Check if base branch is merged (dev merged to feat)
     if (baseBranch.status === 'merged') {
         // Base branch's dev is merged to feat - rebase from base branch's feat branch
@@ -197,6 +226,7 @@ export async function getBaseBranchInfo(branch, allBranches, mainBranch = 'main'
         const featBranchName = baseBranch.branch_name.replace(/^dev\//, 'feat/');
         return {
             baseBranch: featBranchName,
+            originalBaseBranch: baseBranch.branch_name, // Return original dev branch for --onto
             needsRebase: true,
             baseBranchMerged: true,
         };

package/dist/utils/conflict-resolver.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Conflict Resolver
+ * Uses Claude agent to complete the entire rebase process including conflict resolution
+ */
+/**
+ * Configuration for conflict resolution
+ */
+export interface ConflictResolverConfig {
+    model?: string;
+    verbose?: boolean;
+    maxTurns?: number;
+    featureBranch?: string;
+    baseBranch?: string;
+    /**
+     * Original base branch before squash merge.
+     * When provided, this indicates the rebase was started with --onto
+     * to only replay commits after this branch.
+     */
+    originalBaseBranch?: string;
+}
+/**
+ * Result of conflict resolution
+ */
+export interface ConflictResolutionResult {
+    success: boolean;
+    resolvedFiles: string[];
+    failedFiles: string[];
+    error?: string;
+}
+/**
+ * Resolve all conflicts by letting Claude complete the entire rebase process
+ *
+ * This function gives Claude full control to:
+ * 1. Examine the conflict state
+ * 2. Read and understand conflicting files
+ * 3. Edit files to resolve conflicts
+ * 4. Stage resolved files and continue rebase
+ * 5. Repeat until rebase is complete
+ *
+ * @param config - Configuration for conflict resolution
+ * @returns Result of the conflict resolution
+ */
+export declare function resolveConflictsWithAgent(config?: ConflictResolverConfig): Promise<ConflictResolutionResult>;

package/dist/utils/conflict-resolver.js

@@ -0,0 +1,185 @@
+/**
+ * Conflict Resolver
+ * Uses Claude agent to complete the entire rebase process including conflict resolution
+ */
+import { query } from '@anthropic-ai/claude-agent-sdk';
+import { logInfo, logError } from './logger.js';
+import { getConflictFiles, isRebaseInProgress, abortRebase, getCurrentBranch, } from './git-branch-manager.js';
+/**
+ * Create a prompt generator for the Claude agent
+ */
+function* createPromptGenerator(prompt) {
+    yield {
+        type: 'user',
+        message: { role: 'user', content: prompt },
+    };
+}
+/**
+ * Create a system prompt for conflict resolution
+ */
+function createConflictResolutionSystemPrompt() {
+    return `You are a skilled software engineer completing a git rebase operation that has conflicts.
+
+Your task is to resolve ALL merge conflicts and complete the rebase successfully.
+
+WORKFLOW:
+1. First, run "git status" to see the current state and identify all conflicting files
+2. For each conflicting file:
+   a. Read the file to see the conflict markers
+   b. Understand the intent of both sides (ours vs theirs)
+   c. Use the Edit tool to resolve the conflict - merge changes intelligently
+   d. Run "git add <file>" to stage the resolved file
+3. After ALL conflicts are resolved, run "git rebase --continue"
+4. If more conflicts appear from subsequent commits, repeat steps 1-3
+5. Continue until the rebase is complete (no more rebase in progress)
+
+CONFLICT RESOLUTION RULES:
+- Remove ALL conflict markers (<<<<<<, =======, >>>>>>>)
+- Merge changes intelligently - don't just pick one side
+- Preserve functionality from both sides when possible
+- If changes are truly incompatible, prefer theirs (incoming) as it's usually newer
+- Ensure the resulting code is syntactically correct
+- DO NOT add comments explaining the merge
+
+IMPORTANT:
+- Use "git status" to check progress
+- Use the Read tool to examine conflicting files
+- Use the Edit tool to fix conflicts (remove markers, merge content)
+- Use Bash for git commands (git add, git rebase --continue)
+- Keep working until "git status" shows no rebase in progress
+- If you encounter an error you cannot resolve, explain what went wrong`;
+}
+/**
+ * Create the initial prompt describing the rebase task
+ */
+function createRebaseTaskPrompt(featureBranch, baseBranch, conflictFiles, originalBaseBranch) {
+    let context = `A git rebase operation is in progress and has encountered conflicts.
+
+## Current Situation
+- Feature branch: ${featureBranch}
+- Rebasing onto: ${baseBranch}`;
+    if (originalBaseBranch) {
+        context += `
+- Original base branch: ${originalBaseBranch}
+- Note: This is a rebase after squash-merge. The base branch (${originalBaseBranch}) was squash-merged
+  into ${baseBranch}. We used "git rebase --onto" to only replay commits that are new relative to
+  ${originalBaseBranch}. The "theirs" side in conflicts comes from ${baseBranch} (the squashed code).`;
+    }
+    context += `
+- Conflicting files: ${conflictFiles.length > 0 ? conflictFiles.join(', ') : '(run git status to see)'}
+
+## Your Task
+Complete the rebase by resolving all conflicts. Use git status, read the conflicting files, edit them to resolve conflicts, stage with git add, and continue the rebase.
+
+Start by running "git status" to see the current state.`;
+    return context;
+}
+/**
+ * Resolve all conflicts by letting Claude complete the entire rebase process
+ *
+ * This function gives Claude full control to:
+ * 1. Examine the conflict state
+ * 2. Read and understand conflicting files
+ * 3. Edit files to resolve conflicts
+ * 4. Stage resolved files and continue rebase
+ * 5. Repeat until rebase is complete
+ *
+ * @param config - Configuration for conflict resolution
+ * @returns Result of the conflict resolution
+ */
+export async function resolveConflictsWithAgent(config = {}) {
+    const { model = 'sonnet', verbose, maxTurns = 100, featureBranch, baseBranch, originalBaseBranch, } = config;
+    const resolvedFiles = [];
+    if (verbose) {
+        logInfo(`\n🔧 Starting automatic conflict resolution with Claude agent...`);
+    }
+    // Get initial conflict information
+    const currentBranch = featureBranch || getCurrentBranch();
+    const targetBranch = baseBranch || 'main';
+    const initialConflictFiles = getConflictFiles();
+    if (verbose) {
+        logInfo(`   Feature branch: ${currentBranch}`);
+        logInfo(`   Rebasing onto: ${targetBranch}`);
+        if (originalBaseBranch) {
+            logInfo(`   Original base (--onto): ${originalBaseBranch}`);
+        }
+        logInfo(`   Initial conflicts: ${initialConflictFiles.length} file(s)`);
+    }
+    const systemPrompt = createConflictResolutionSystemPrompt();
+    const userPrompt = createRebaseTaskPrompt(currentBranch, targetBranch, initialConflictFiles, originalBaseBranch);
+    try {
+        let lastMessage = '';
+        for await (const message of query({
+            prompt: createPromptGenerator(userPrompt),
+            options: {
+                systemPrompt: {
+                    type: 'preset',
+                    preset: 'claude_code',
+                    append: systemPrompt,
+                },
+                model: model,
+                maxTurns: maxTurns,
+                permissionMode: 'bypassPermissions',
+            },
+        })) {
+            if (verbose && message.type === 'assistant' && message.message?.content) {
+                // Log progress
+                const content = message.message.content;
+                if (typeof content === 'string') {
+                    lastMessage = content;
+                }
+                else if (Array.isArray(content)) {
+                    for (const block of content) {
+                        if (block.type === 'text') {
+                            lastMessage = block.text;
+                        }
+                    }
+                }
+            }
+        }
+        // Check if rebase completed successfully
+        if (!isRebaseInProgress()) {
+            if (verbose) {
+                logInfo(`✅ Rebase completed successfully`);
+            }
+            // Get the list of files that were resolved (approximate from initial conflicts)
+            return {
+                success: true,
+                resolvedFiles: initialConflictFiles,
+                failedFiles: [],
+            };
+        }
+        else {
+            // Rebase still in progress - something went wrong
+            const remainingConflicts = getConflictFiles();
+            if (verbose) {
+                logError(`❌ Rebase still in progress with ${remainingConflicts.length} conflicts`);
+                if (lastMessage) {
+                    logError(`   Last message: ${lastMessage.substring(0, 200)}...`);
+                }
+            }
+            abortRebase(verbose);
+            return {
+                success: false,
+                resolvedFiles: [],
+                failedFiles: remainingConflicts,
+                error: `Rebase not completed. Remaining conflicts: ${remainingConflicts.join(', ')}`,
+            };
+        }
+    }
+    catch (error) {
+        if (verbose) {
+            logError(`❌ Error during conflict resolution: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        // Try to abort rebase to leave repo in clean state
+        if (isRebaseInProgress()) {
+            abortRebase(verbose);
+        }
+        return {
+            success: false,
+            resolvedFiles: [],
+            failedFiles: getConflictFiles(),
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}

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

@@ -2,6 +2,20 @@
  * 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
  */
@@ -18,6 +32,34 @@ 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
  */
@@ -102,3 +144,78 @@ export declare function prepareCustomBranchGitEnvironment(featureBranch: string,
  * @param verbose - Whether to log verbose output
  */
 export declare function syncFeatBranchWithMain(featureId: string, githubToken: string, owner: string, repo: string, baseBranch?: string, verbose?: boolean): Promise<boolean>;
+/**
+ * Options for async rebase with conflict resolution
+ */
+export interface RebaseWithConflictResolutionOptions {
+    featureBranch: string;
+    baseBranch?: string;
+    /**
+     * Original base branch before squash merge.
+     * When set, uses `git rebase --onto baseBranch originalBaseBranch` to only
+     * rebase commits that are new relative to originalBaseBranch.
+     * This is required when the base branch was squash-merged, otherwise
+     * git will try to reapply all the original commits causing many conflicts.
+     */
+    originalBaseBranch?: string;
+    verbose?: boolean;
+    resolveConflicts?: boolean;
+    conflictResolverConfig?: {
+        model?: string;
+        maxTurns?: number;
+    };
+}
+/**
+ * Switch to feature 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
+ */
+export declare function switchToFeatureBranchAndRebaseAsync(options: RebaseWithConflictResolutionOptions): Promise<{
+    previousBranch: string;
+    conflictsResolved?: boolean;
+    resolvedFiles?: string[];
+}>;
+/**
+ * Async version of prepareCustomBranchGitEnvironment with conflict resolution support.
+ *
+ * Usage:
+ *   const cleanup = await prepareCustomBranchGitEnvironmentAsync({
+ *     featureBranch: '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 declare function prepareCustomBranchGitEnvironmentAsync(options: RebaseWithConflictResolutionOptions): Promise<{
+    cleanup: () => void;
+    conflictsResolved?: boolean;
+    resolvedFiles?: string[];
+}>;
+/**
+ * Async version of preparePhaseGitEnvironment with conflict resolution support.
+ *
+ * @param featureId - The feature ID (will be used to construct branch name "dev/{featureId}")
+ * @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 declare function preparePhaseGitEnvironmentAsync(featureId: string, baseBranch?: string, verbose?: boolean, resolveConflicts?: boolean, conflictResolverConfig?: {
+    model?: string;
+    maxTurns?: number;
+}): Promise<{
+    cleanup: () => void;
+    conflictsResolved?: boolean;
+    resolvedFiles?: string[];
+}>;

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

@@ -3,6 +3,8 @@
  * Shared utilities for consistent git branch management across all phases
  */
 import { execSync } from 'child_process';
+import * as fs from 'fs';
+import * as path from 'path';
 import { Octokit } from '@octokit/rest';
 import { logInfo, logError } from './logger.js';
 /**
@@ -62,6 +64,148 @@ export function resetUncommittedChanges(verbose) {
         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
  */
@@ -476,3 +620,238 @@ export async function syncFeatBranchWithMain(featureId, githubToken, owner, repo
         return false;
     }
 }
+/**
+ * Switch to feature 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
+ */
+export async function switchToFeatureBranchAndRebaseAsync(options) {
+    const { featureBranch, baseBranch = 'main', originalBaseBranch, verbose, resolveConflicts = false, conflictResolverConfig, } = options;
+    const previousBranch = getCurrentBranch();
+    if (verbose) {
+        logInfo(`\n🔄 Preparing feature branch: ${featureBranch}`);
+        logInfo(`   Current branch: ${previousBranch}`);
+    }
+    // If feature branch doesn't exist, we need to create it from base branch
+    if (!branchExists(featureBranch)) {
+        if (verbose) {
+            logInfo(`   Feature branch ${featureBranch} doesn't exist, will create from ${baseBranch}`);
+        }
+        // First, ensure we're on the base branch to create feature branch from it
+        if (previousBranch !== baseBranch) {
+            if (verbose) {
+                logInfo(`   Switching to ${baseBranch} first...`);
+            }
+            switchToBranch(baseBranch, verbose);
+        }
+        // Pull latest base branch before creating feature branch
+        try {
+            if (verbose) {
+                logInfo(`   Pulling latest ${baseBranch}...`);
+            }
+            pullLatestFromBranch(baseBranch, verbose);
+        }
+        catch (error) {
+            if (verbose) {
+                logInfo(`   ⚠️  Could not pull ${baseBranch}, will create branch from local ${baseBranch}`);
+            }
+        }
+    }
+    // Switch to feature branch (will create if doesn't exist)
+    if (getCurrentBranch() !== featureBranch) {
+        switchToBranch(featureBranch, verbose);
+    }
+    // Sync with remote feature branch if it exists
+    try {
+        if (hasUncommittedChanges()) {
+            if (verbose) {
+                logInfo(`⚠️  Found uncommitted changes. Resetting to clean state before sync...`);
+            }
+            resetUncommittedChanges(verbose);
+        }
+        execSync('git fetch origin', { encoding: 'utf-8', stdio: 'pipe' });
+        try {
+            execSync(`git rev-parse --verify origin/${featureBranch}`, {
+                encoding: 'utf-8',
+                stdio: 'pipe',
+            });
+            if (verbose) {
+                logInfo(`📥 Syncing with remote feature branch origin/${featureBranch}...`);
+            }
+            execSync(`git reset --hard origin/${featureBranch}`, {
+                encoding: 'utf-8',
+                stdio: 'pipe',
+            });
+            if (verbose) {
+                logInfo(`✅ Synced local branch with origin/${featureBranch}`);
+            }
+        }
+        catch (e) {
+            if (verbose) {
+                logInfo(`   Remote branch origin/${featureBranch} doesn't exist yet, will create on push`);
+            }
+        }
+    }
+    catch (error) {
+        if (verbose) {
+            logInfo(`⚠️  Could not sync with remote feature branch, continuing with local branch`);
+        }
+    }
+    // Rebase feature branch with latest base branch
+    if (verbose) {
+        if (originalBaseBranch) {
+            logInfo(`📥 Rebasing ${featureBranch} onto origin/${baseBranch} (from ${originalBaseBranch})...`);
+        }
+        else {
+            logInfo(`📥 Rebasing ${featureBranch} with origin/${baseBranch}...`);
+        }
+    }
+    try {
+        if (hasUncommittedChanges()) {
+            if (verbose) {
+                logInfo(`⚠️  Found uncommitted changes. Resetting to clean state before rebase...`);
+            }
+            resetUncommittedChanges(verbose);
+        }
+        // Fetch the base branch first
+        execSync(`git fetch origin ${baseBranch}`, {
+            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>
+            if (verbose) {
+                logInfo(`   Using --onto to rebase only new commits (after ${originalBaseBranch})`);
+            }
+            execSync(`git rebase --onto origin/${baseBranch} origin/${originalBaseBranch}`, {
+                encoding: 'utf-8',
+                stdio: verbose ? 'inherit' : 'pipe',
+            });
+        }
+        else {
+            // Normal rebase
+            execSync(`git rebase origin/${baseBranch}`, {
+                encoding: 'utf-8',
+                stdio: verbose ? 'inherit' : 'pipe',
+            });
+        }
+        if (verbose) {
+            logInfo(`✅ Successfully rebased ${featureBranch} with origin/${baseBranch}\n`);
+        }
+        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,
+                featureBranch,
+                baseBranch,
+                originalBaseBranch,
+            });
+            if (result.success) {
+                if (verbose) {
+                    logInfo(`✅ Successfully resolved conflicts and rebased ${featureBranch} with origin/${baseBranch}\n`);
+                }
+                return {
+                    previousBranch,
+                    conflictsResolved: true,
+                    resolvedFiles: result.resolvedFiles,
+                };
+            }
+            else {
+                // Conflict resolution failed, abort rebase
+                abortRebase(verbose);
+                throw new Error(`Failed to automatically resolve conflicts during rebase ${featureBranch} with ${baseBranch}.\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 ${featureBranch} with ${baseBranch}: ${error instanceof Error ? error.message : String(error)}\n` +
+            `This usually means there are conflicts between your feature 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({
+ *     featureBranch: '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;
+    // Create cleanup function BEFORE any operations that might fail
+    const cleanup = () => {
+        returnToMainBranch('main', verbose);
+    };
+    try {
+        const result = await switchToFeatureBranchAndRebaseAsync(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 featureId - The feature ID (will be used to construct branch name "dev/{featureId}")
+ * @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(featureId, baseBranch = 'main', verbose, resolveConflicts, conflictResolverConfig) {
+    const featureBranch = `dev/${featureId}`;
+    return prepareCustomBranchGitEnvironmentAsync({
+        featureBranch,
+        baseBranch,
+        verbose,
+        resolveConflicts,
+        conflictResolverConfig,
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "edsger",
-  "version": "0.19.14",
+  "version": "0.19.16",
   "type": "module",
   "bin": {
     "edsger": "dist/index.js"