---

name: dev-swarm-git-merge description: Perform git partial merges (checkout specific folders from another branch) and squash merges (clean single-commit integration) to selectively integrate changes across branches.

AI Builder - Git Partial and Clean Merge

This skill helps you perform advanced git merge strategies including partial merges (checking out specific folders from another branch) and squash merges (clean single-commit integration).

When to Use This Skill

• User asks to merge specific folders or files from another branch
• User wants to perform a partial merge without merging the entire branch
• User asks to squash merge a feature branch into main
• User wants a clean, single-commit integration without preserving commit history
• User needs to selectively sync components between branches

Your Roles in This Skill

• DevOps Engineer: Execute git commands safely, verify branch states, and ensure clean merge operations.
• Project Manager: Guide the user through merge strategy selection and validate the merge scope.

Role Communication

As an expert in your assigned roles, you must announce your actions before performing them using the following format:

As a {Role} [and {Role}, ...], I will {action description}

This communication pattern ensures transparency and allows for human-in-the-loop oversight at key decision points.

Instructions

Follow these steps to perform git partial or clean merges:

Step 1: Understand the Merge Requirements

As a Project Manager, ask the user to clarify:

1. What type of merge do they need?

   • Partial merge: Merge specific folders/files only
   • Squash merge: Merge all changes as a single commit

2. For partial merge:

   • Which source branch contains the folders/files?
   • Which specific folders/files need to be merged?
   • Which target branch should receive them?

3. For squash merge:

   • Which source branch to merge from?
   • Which target branch to merge into?
   • What should the commit message be?

Step 2: Check Git Status

As a DevOps Engineer, verify the current state:

# Check current branch
git branch

# Check for uncommitted changes
git status

# View recent branches
git branch -a

Important: If there are uncommitted changes, ask the user whether to:

• Stash them: git stash
• Commit them first
• Abort the merge operation

Step 3: Perform the Merge

Option A: Partial Merge (Specific Folders/Files)

As a DevOps Engineer, execute the partial merge:

# Switch to the target branch (where you want the folders)
git checkout target-branch

# Checkout specific folders from source branch
git checkout source-branch -- path/to/folder1 path/to/folder2

# Stage the changes
git add path/to/folder1 path/to/folder2

# Commit the changes
git commit -m "Merge specific folders from source-branch"

Example:

# Merge only the docs and config folders from feature-branch to main
git checkout main
git checkout feature-branch -- docs config
git add docs config
git commit -m "Sync docs and config from feature-branch"

Option B: Squash Merge (Clean Single-Commit)

As a DevOps Engineer, execute the squash merge:

# Switch to target branch
git checkout target-branch

# Perform squash merge (stages all changes but doesn't commit)
git merge --squash source-branch

# Review staged changes
git status

# Commit with a meaningful message
git commit -m "Add feature: descriptive message summarizing all changes"

Example:

# Squash merge a feature branch into main
git checkout main
git merge --squash feature/user-authentication
git commit -m "Add user authentication feature with JWT and OAuth support"

Step 4: Verify the Merge

As a DevOps Engineer, verify the merge was successful:

# Check the commit was created
git log -1

# Verify the changes
git diff HEAD~1

# Check branch status
git status

Step 5: Push Changes (Optional)

As a Project Manager, ask the user if they want to push:

If yes, as a DevOps Engineer:

# Push to remote
git push origin target-branch

Merge Strategy Comparison

| Aspect | Partial Merge | Squash Merge | |--------|---------------|--------------| | Scope | Selective files/folders only | All changes from branch | | Commit History | Not applicable | Squashed into one commit | | Use Case | Selective sync of components | Clean integration of features | | Reversibility | Easy to revert specific files | Reverts entire feature at once |

Best Practices

Partial Merge:

• Always review changes with git diff before committing
• Use meaningful commit messages indicating source branch
• Verify the correct folders/files are staged before committing

Squash Merge:

• Write comprehensive commit messages that summarize all changes
• Review all staged changes before committing
• Document breaking changes or important notes in the commit message
• Consider keeping the source branch until changes are confirmed working

General:

• Always work on a clean working directory (commit or stash changes first)
• Test changes thoroughly after merge
• Communicate merge strategy with team members
• Use git status frequently to verify state

Examples

Example 1: Merge Documentation from Feature Branch

git checkout main
git checkout feature/new-api -- docs/api
git add docs/api
git commit -m "Update API documentation from feature/new-api"

Example 2: Squash Merge Feature Branch

git checkout main
git merge --squash feature/shopping-cart
git commit -m "Add shopping cart feature with add/remove/checkout functionality"
git push origin main

Example 3: Merge Multiple Folders

git checkout develop
git checkout feature/redesign -- src/components src/styles
git add src/components src/styles
git commit -m "Merge redesigned components and styles from feature/redesign"

Common Issues

Issue: "error: pathspec 'folder' did not match any file(s) known to git"

• Solution: The folder/file doesn't exist in the source branch. Verify with git ls-tree -r source-branch --name-only

Issue: Merge conflicts during squash merge

• Solution: Resolve conflicts manually, then git add the resolved files and git commit

Issue: Accidentally merged wrong folders

• Solution: If not pushed yet, use git reset HEAD~1 to undo the commit, then repeat with correct paths

Issue: Uncommitted changes blocking checkout

• Solution: Stash changes with git stash, perform merge, then git stash pop