option
MaisonMaison Skill Révision du code pull-changes-resolve-conflicts

pull-changes-resolve-conflicts

cognitedata/builder-skills cognitedata/builder-skills

Workflow standard pour récupérer des mises à jour depuis la branche principale ou d’autres branches dans les projets impliquant plusieurs contributeurs (y compris les applications Flows), sans jeter silencieusement le travail déjà effectué. Ce guide explique comment effectuer les récupérations et les fusionnements, exige une liste explicite des conflits de fusion, analyse ceux-ci en se basant sur l’historique des conversations et le contexte du dépôt, propose des recommandations classées par priorité, et sollicite les réponses de l’utilisateur avant d’éditer les marqueurs de conflit ou de finaliser la fusion. Déclencheurs : récupération depuis la branche principale, fusion avec la branche principale, fusion avec la branche originale, rebase, conflit de fusion, fichier non fusionné.

...Développer tout
11
Heure mise à jour 26 août 2026

À propos de pull-changes-resolve-conflicts

Un flux de travail guidé pour intégrer une branche dans une autre (généralement en tirant les modifications de la branche principale vers une branche fonctionnelle) dans des projets impliquant plusieurs contributeurs, sans jeter silencieusement du travail intentionnel. Il s’applique à tout flux de travail d’équipe basé sur Git, les applications Flows/React étant un cas fréquent où les conflits ont tendance à apparaître dans les structures d’application, la navigation principale, les modules de routes, ainsi que dans les répertoires partagés lib/ ou hooks/. Le principe fondamental est que la résolution des conflits ne doit jamais supposer a priori que « la branche principale l’emporte » ou « notre version l’emporte », et que les compromis doivent être rendus visibles à l’utilisateur avant toute modification des marqueurs de conflit.

Le flux de travail se déroule en plusieurs étapes : récupération et intégration (on préfère d’abord git fetch suivi de git merge origin/main, sauf si une rebase a été demandée), puis indication explicite de chaque fichier non fusionné accompagnée d’une brève explication sur ce qui a provoqué la divergence, suivie d’une analyse à l’aide de l’historique des discussions, des signaux du dépôt (comme un PRD.md ou des commits récents), ainsi que des parties concernées par le conflit via git show :2:path (notre version) et git show :3:path (leur version). Les conflits sont classés en orthogonaux (peuvent être combinés sans problème), en chevauchants (il faut choisir ou fusionner manuellement), ou présentant un risque de corruption (blocs dupliqués dus à des fusions incorrectes). Les résultats sont ensuite présentés sous forme de recommandations hiérarchisées et de questions précises, classées de P0 (changements structurels ou liés au produit tels que suppression de routes, suppression de fonctionnalités, modification des données ou des contrats API) à P3 (ajustements de présentation comme l’espacement ou les noms de classes).

Des règles strictes interdisent toute résolution silencieuse : les marqueurs de conflit ne sont pas supprimés et git add n’est pas exécuté tant que l’utilisateur n’a pas approuvé le plan ou n’a pas explicitement choisi de suivre les recommandations. L’outil s’arrête aux conflits sans forcer l’intégration de fichiers volumineux, et permet d’annuler l’opération via git merge --abort ou git rebase --abort. Il liste également des anti-modèles à éviter, tels que le choix systématique de --ours ou --theirs dans tout le dépôt, ou la dissimulation d’une liste de conflits au sein d’un long bloc de code sans résumé succinct. Des extraits de commandes optionnels et un modèle de message de fusion se trouvent dans le fichier reference.md accompagnant l’outil.

FAQ

Quand dois-je utiliser cet outil ?

Chaque fois que vous intégrez une autre branche (généralement la branche principale) dans votre branche fonctionnelle actuelle, ou lorsque git status indique des chemins non fusionnés après une fusion ou une rebase. Il s’applique à tout flux de travail d’équipe basé sur Git, les applications Flows/React étant un cas courant.

Va-t-il résoudre automatiquement les conflits sans me demander mon avis ?

Non. Une règle stricte interdit toute résolution silencieuse : il ne supprimera pas les marqueurs de conflit ni n’exécutera git add tant que vous n’avez pas approuvé le plan ou indiqué explicitement de suivre ses recommandations. Il s’arrête aux conflits et les signale en premier.

Comment décide-t-il quels conflits aborder en premier ?

Les conflits sont classés selon leur impact, de P0 (changements structurels ou liés au produit tels que suppression de routes, suppression de fonctionnalités, ou modification des données et des contrats API) jusqu’à P3 (ajustements de présentation comme l’espacement, les noms de classes ou le texte affiché).

Quelles informations utilise-t-il pour analyser un conflit avant de le modifier ?

Il utilise l’historique des discussions concernant les modifications prévues pour la branche, des signaux du dépôt tels qu’un PRD.md ou des commits récents ainsi que l’auteur des fichiers, et les parties concernées par le conflit via git show :2:path pour notre version et git show :3:path pour la leur.

Que se passe-t-il si je veux simplement annuler la fusion ?

L’outil permet d’exécuter git merge --abort ou git rebase --abort selon le cas, et indique que l’état d’intégration en cours sera perdu suite à cette opération.

Tous les fichiers

2 fichiersreference.md0,7 KBAfficherSKILL.md5,5 KBAfficher

Voir sur GitHub

Use this skill whenever integrating another branch (usually main) into the current feature branch, or when git status shows unmerged paths after a merge or rebase. Applies to any Git-based team workflow; Flows/React apps are a common case where conflicts cluster in app shells and shared libraries.

Goals

  • Preserve intentional work on the current branch; do not assume “main wins” or “ours wins” without analysis.
  • Make trade-offs visible to the user before any conflict resolution edits.
  • Order discussion by impact: structural / feature / API / data-model changes before styling, copy, or spacing.

Hard rules

  1. No silent resolution — Do not remove <<<<<<< / ======= / >>>>>>> or run git add on conflicted files until the user has agreed to the plan (or explicitly says “use your recommendations”).
  2. Stop at conflicts — If a merge or rebase introduces conflicts, pause and report; do not bulldoze through large files by picking one side wholesale unless the user explicitly requests that.
  3. Prioritize impact — When presenting conflicts, group and order roughly as:
    • P0 — Structural / product: removed routes, deleted modules, dropped features, changed data or API contracts, SDK or schema changes, auth or routing shell.
    • P1 — Behavior: logic, hooks, queries, filters, error handling, loading states.
    • P2 — UI structure: layout regions, new or removed sections, navigation.
    • P3 — Presentation: tokens, spacing, class names, copy tweaks.

Workflow

1. Fetch and integrate (or diagnose)

  • Prefer git fetch then git merge origin/main (or the named branch) unless the user asked for rebase.
  • If merge is already in progress, run git status and list every unmerged file.

2. Report conflicts to the user (explicit)

Output a clear list:

  • Branch state: current branch, target branch (e.g. origin/main), merge vs rebase.
  • Unmerged files: paths only, then optionally git diff --name-only --diff-filter=U.
  • Per file (short): one line on what diverged (e.g. “AlertsPage — layout + new data scope”) if inferable from paths and git diff without resolving.

3. Analyze before editing

Use all of:

  • Conversation history — What was the user or team trying to ship on this branch?
  • Repo signals — Product or architecture docs if present (e.g. PRD.md), recent commits on the current branch, file ownership (e.g. large feature module vs shared lib/).
  • Conflict hunks — git show :2:path (ours) vs git show :3:path (theirs) during merge, or read conflict markers; identify duplicated vs orthogonal changes.

Classify each conflicted area as:

  • Orthogonal — safe to combine (e.g. import sort + new prop).
  • Overlapping — must choose or manually merge (same lines).
  • Corruption risk — duplicated blocks (common after bad merges); flag and recommend reconstructing from one side then re-applying the other side’s intent manually.

4. Recommendations + questions (required)

Present to the user:

  1. Summary table or bullets — file → recommended side or “manual merge” → one-line why.
  2. Ordered by P0 → P3 — call out anything that removes a feature or changes public behavior first.
  3. Explicit questions — anything ambiguous (e.g. “Keep main’s global behavior or the branch’s scoped variant?”).
  4. Ask for direction — e.g. “Reply with: (a) follow recommendations, (b) keep branch for file X, (c) keep main for file Y, (d) abort merge.”

Only after the user confirms (or gives a precise mapping), apply resolutions:

  • Prefer small, surgical edits; preserve both sides’ intent when possible.
  • Re-run git status; ensure no conflict markers remain; run tests or lint the user cares about for touched areas.

5. If the user wants to abort

  • git merge --abort or git rebase --abort as appropriate; confirm they lose in-progress integration state for that operation.

Anti-patterns (do not do)

  • Picking --ours / --theirs on the whole repo without user approval.
  • “Resolving” by deleting a feature branch’s work because main touched the same file.
  • Hiding conflict lists inside a long code dump without a short executive summary.
  • Fixing low-impact style conflicts first while leaving P0 decisions implicit.

Quick reference

  • Ours vs theirs (merge): stage 2 = current branch (HEAD), stage 3 = incoming (MERGE_HEAD). Verify with git checkout --conflict=merge <file> if needed.
  • Typical high-touch paths in full-stack or Flows apps: root app shell, top navigation, route modules, and shared lib/ or hooks/.

For optional command snippets and a merge message template, see reference.md.

Tous les fichiers

0 fichiers

Installer pull-changes-resolve-conflicts

Téléchargez et extrayez les fichiers de compétences dans votre répertoire .claude/skills/.

Télécharger le ZIP

Clonez le dépôt et copiez les fichiers de compétence dans votre projet.

git clone https://github.com/cognitedata/builder-skills/blob/main/skills/pull-changes-resolve-conflicts/SKILL.md # Copy SKILL.md to your .claude/skills/ directory

Copier Copier
Configuration rapide: Copiez le dossier de la compétence dans .claude/skills/Claude détectera automatiquement cette compétence et l’utilisera.

Compétences similaires

code-simplify
Heure mise à jour 2 juillet 2026
requesting-code-review
Heure mise à jour 29 juin 2026
Git Commit Helper
Heure mise à jour 29 juin 2026
commit-standards
Heure mise à jour 29 juin 2026
OR