name: git-apply-from-commit description: Carefully apply changes from a specific git commit to the current branch. model: inherit

git-apply-from-commit

Replay a commit from another PR onto the current branch, adapting for base branch changes and user-specified modifications.

When to Use

Use this skill when the user wants to:

• Cherry-pick a commit but the base branch has diverged significantly
• Apply changes from another PR with modifications
• Replay work from a stale branch onto a fresh one
• Port a feature/fix from one branch to another with adjustments

Required Input

1. Commit reference - One of:

   • PR number (e.g., #123)
   • Commit SHA (e.g., abc1234)
   • GitHub PR URL (e.g., https://github.com/org/repo/pull/123)

2. User's modification notes - What they want different from the original

Approach

Phase 1: Fetch and Understand the Original Commit

# If given a PR number, get the commits
gh pr view <PR_NUMBER> --json commits

# View the full diff of the PR
gh pr diff <PR_NUMBER>

# Or if given a commit SHA directly
git show <COMMIT_SHA>

Read and understand:

• What files were changed
• What the commit was trying to accomplish
• The context and intent behind the changes

Phase 2: Analyze Current State

1. Read the relevant files on the current branch - Understand current implementations
2. Identify base branch drift:
   • Renamed files or moved code
   • Refactored patterns or abstractions
   • New dependencies or removed ones
   • Changed APIs or interfaces
3. Note conflicts - Where the original changes would clash with current state

Phase 3: Gather User Requirements

Use AskUserQuestion to clarify:

• Specific modifications they want
• How to handle ambiguous conflicts
• Priority if there are trade-offs

DO NOT proceed with code changes until requirements are clear.

Phase 4: Apply Changes Intelligently

Do NOT use blind git cherry-pick - it often fails with diverged branches and creates messy conflicts.

Instead:

1. Manually apply the intent of the commit, not just the diff
2. Adapt to current:
   • File locations and names
   • Code patterns and conventions
   • API signatures and interfaces
3. Incorporate user's requested modifications
4. Resolve conflicts based on context, not just syntax

Phase 5: Review Before Committing

1. Show the user what changed using git diff
2. Explain any adaptations made due to base branch changes
3. Highlight where user's modifications were applied
4. Get approval before creating the commit

Example Usage

User: "Replay commit abc123 from PR #456 onto this branch. But I want to use the new ApiClient instead of the old HttpService."

Agent actions:

1. gh pr diff 456 - View the original changes
2. Read current files that would be affected
3. Note that HttpService was refactored to ApiClient in base
4. Apply the commit's logic using ApiClient
5. Show diff to user for approval
6. Commit with appropriate message

Notes

• Always read files before modifying them
• Preserve the original commit's intent while adapting implementation
• When in doubt, ask the user
• Reference the original commit/PR in the new commit message for traceability