Cherry-Picking

Before:
main:    A---B---C
              \
feature:       D---E---F

After cherry-picking E to main:
main:    A---B---C---E'
feature:       D---E---F

E' is a new commit with same changes as E but different SHA

// From app/src/lib/git/cherry-pick.ts
export async function cherryPick(
  repository: Repository,
  commits: ReadonlyArray<CommitOneLine>,
  progressCallback?: (progress: IMultiCommitOperationProgress) => void
): Promise<CherryPickResult> {
  if (commits.length === 0) {
    return CherryPickResult.UnableToStart
  }
  
  const baseOptions: IGitStringExecutionOptions = {
    expectedErrors: new Set([
      GitError.MergeConflicts,
      GitError.ConflictModifyDeletedInBranch,
    ]),
  }
  
  // --empty=keep: Keep commits even if they become empty
  // -m 1: For merge commits, use first parent
  const result = await git(
    ['cherry-pick', ...commits.map(c => c.sha), '--empty=keep', '-m 1'],
    repository.path,
    'cherry-pick',
    baseOptions
  )
  
  return parseCherryPickResult(result)
}

class GitCherryPickParser {
  parse(line: string): IMultiCommitOperationProgress | null {
    const cherryPickRe = /^\[(.*\s.*)\]/
    const match = cherryPickRe.exec(line)
    
    if (match === null) {
      return null  // Skip non-commit lines
    }
    
    this.count++
    
    return {
      kind: 'multiCommitOperation',
      value: round(this.count / this.commits.length, 2),
      position: this.count,
      totalCommitCount: this.commits.length,
      currentCommitSummary: this.commits[this.count - 1]?.summary ?? '',
    }
  }
}

[main a1b2c3d] Fix critical bug
 Date: Mon Mar 5 10:30:00 2024
 1 file changed, 1 insertion(+)

export enum CherryPickResult {
  CompletedWithoutError,      // Success!
  ConflictsEncountered,       // Need to resolve conflicts
  OutstandingFilesNotStaged,  // Files need staging
  UnableToStart,              // Can't begin cherry-pick
  Error,                      // Unexpected error
}

function parseCherryPickResult(result: IGitResult): CherryPickResult {
  if (result.exitCode === 0) {
    return CherryPickResult.CompletedWithoutError
  }
  
  switch (result.gitError) {
    case GitError.ConflictModifyDeletedInBranch:
    case GitError.MergeConflicts:
      return CherryPickResult.ConflictsEncountered
    case GitError.UnresolvedConflicts:
      return CherryPickResult.OutstandingFilesNotStaged
    default:
      throw new Error(`Unhandled result: ${JSON.stringify(result)}`)
  }
}

export async function continueCherryPick(
  repository: Repository,
  files: ReadonlyArray<WorkingDirectoryFileChange>,
  manualResolutions: ReadonlyMap<string, ManualConflictResolution>,
  progressCallback?: (progress: IMultiCommitOperationProgress) => void
): Promise<CherryPickResult> {
  // Only stage tracked files (ignore untracked)
  const trackedFiles = files.filter(f => {
    return f.status.kind !== AppFileStatusKind.Untracked
  })
  
  // Apply manual resolutions
  for (const [path, resolution] of manualResolutions) {
    await stageManualConflictResolution(repository, file, resolution)
  }
  
  await stageFiles(repository, otherFiles)
  
  // Check if commit is now empty
  const status = await getStatus(repository)
  const trackedFilesAfter = status.workingDirectory.files.filter(
    f => f.status.kind !== AppFileStatusKind.Untracked
  )
  
  if (trackedFilesAfter.length === 0) {
    // Commit is empty - still include it with --allow-empty
    await git(['commit', '--allow-empty'])
  } else {
    // Continue with the cherry-pick
    await git(['cherry-pick', '--continue'])
  }
}

export async function abortCherryPick(repository: Repository) {
  await git(['cherry-pick', '--abort'], repository.path, 'abortCherryPick')
}

export async function isCherryPickHeadFound(
  repository: Repository
): Promise<boolean> {
  try {
    const cherryPickHeadPath = Path.join(
      repository.path,
      '.git',
      'CHERRY_PICK_HEAD'
    )
    return pathExists(cherryPickHeadPath)
  } catch (err) {
    log.warn('[cherryPick] Cannot read CHERRY_PICK_HEAD')
    return false
  }
}

export async function getCherryPickSnapshot(
  repository: Repository
): Promise<ICherryPickSnapshot | null> {
  if (!isCherryPickHeadFound(repository)) {
    return null
  }
  
  // Read sequencer files:
  // .git/sequencer/abort-safety - last successfully picked commit SHA
  // .git/sequencer/head - original HEAD before cherry-pick
  // .git/sequencer/todo - remaining commits to pick
  
  const remainingPicks = await readFile(
    Path.join(repository.path, '.git', 'sequencer', 'todo')
  )
  
  // Parse format: "pick shortSha commitSummary"
  const remainingCommits: CommitOneLine[] = []
  remainingPicks.split('\n').forEach(line => {
    line = line.replace(/^pick /, '')
    if (line.includes(' ')) {
      const sha = line.substr(0, line.indexOf(' '))
      const summary = line.substr(sha.length + 1)
      remainingCommits.push({ sha, summary })
    }
  })
  
  return {
    progress: { /* ... */ },
    remainingCommits,
    commits: [...pickedCommits, ...remainingCommits],
    targetBranchUndoSha: headSha,
  }
}

git cherry-pick -m 1 <merge-commit-sha>

git cherry-pick --empty=keep <sha>

Scenario: Fix found in main, need in release branch

1. Checkout release-1.0 branch
2. Find fix commit in main branch history
3. Cherry-pick the fix commit
4. Test the fix works in release branch
5. Push to update release

Scenario: Critical fix needed in v1.0, v2.0, and main

1. Create fix in hotfix branch
2. Cherry-pick to release-1.0
3. Cherry-pick to release-2.0  
4. Cherry-pick to main
5. Or merge hotfix to main, cherry-pick to releases

Scenario: Want specific commits from feature branch

1. Identify which commits to include
2. Checkout target branch (e.g., main)
3. Select and cherry-pick desired commits
4. Test that partial feature works
5. Commit and push

Fix login timeout issue

(cherry picked from commit a1b2c3d4e5f6g7h8i9j0)

Original fix was in main branch. Backporting to release-1.0
for critical bug fix.

git cherry-pick -x <sha>  # Adds "(cherry picked from...)" line