@gitwand/core 2.5.0 → 2.6.0

package/dist/refactoring/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * GitWand v2.6 — Module refactoring (point d'entrée)
+ *
+ * Exporte le pipeline RefMerge et ses composants publics.
+ * Les exports internes (`detect`, `invert`, `replay`) sont volontairement
+ * exposés pour permettre des tests unitaires granulaires.
+ */
+export { detectRefactorings } from "./detect.js";
+export { invertRefactorings } from "./invert.js";
+export { replayRefactorings, mergeRefactorings } from "./replay.js";
+export { tryRefMerge } from "./orchestration.js";
+export type { RefMergeResult } from "./orchestration.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/refactoring/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/refactoring/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AACpE,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACjD,YAAY,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/refactoring/index.js

@@ -0,0 +1,12 @@
+/**
+ * GitWand v2.6 — Module refactoring (point d'entrée)
+ *
+ * Exporte le pipeline RefMerge et ses composants publics.
+ * Les exports internes (`detect`, `invert`, `replay`) sont volontairement
+ * exposés pour permettre des tests unitaires granulaires.
+ */
+export { detectRefactorings } from "./detect.js";
+export { invertRefactorings } from "./invert.js";
+export { replayRefactorings, mergeRefactorings } from "./replay.js";
+export { tryRefMerge } from "./orchestration.js";
+//# sourceMappingURL=index.js.map

package/dist/refactoring/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/refactoring/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AACpE,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/refactoring/invert.d.ts

@@ -0,0 +1,53 @@
+/**
+ * GitWand v2.6 — Inversion de refactorings (expérimental)
+ *
+ * Inverse les refactorings détectés par `detect.ts` pour ramener une branche
+ * à la nomenclature de la version de base avant la résolution textuelle.
+ *
+ * ## Rôle dans le pipeline RefMerge
+ *
+ * ```
+ * base ──────────────────────────────────────────────────────┐
+ *        ↘ (refactorings ours)                               │
+ * ours ──→ invertRefactorings(ours, refs_ours) ──→ ours'     ├─→ merge textuel → merged'
+ *        ↘ (refactorings theirs)                             │
+ * theirs → invertRefactorings(theirs, refs_theirs) → theirs' ┘
+ * ```
+ *
+ * Après inversion, `ours'` et `theirs'` utilisent la même nomenclature que
+ * `base`, ce qui rend le merge textuel robuste aux conflits de renommage.
+ *
+ * ## Algorithme
+ *
+ * Pour chaque `Refactoring` dans la liste :
+ * - `rename-local`     : remplacer `newName` → `oldName` dans la portée (`scope`)
+ * - `rename-top-level` : remplacer `newName` → `oldName` dans tout le fichier
+ * - `move-method`      : aucune inversion textuelle possible à ce stade
+ *                        (la méthode est déjà dans la classe cible — on laisse)
+ *
+ * ## Garanties
+ * - Retourne les lignes inchangées si la liste de refactorings est vide.
+ * - Retourne les lignes inchangées en cas d'erreur (safe by default).
+ * - Zéro import Node.js — compatible browser, Node.js, Tauri WebView.
+ */
+import type { Refactoring } from "../types.js";
+/**
+ * Inverse une liste de refactorings dans les lignes d'une branche.
+ *
+ * Applique les inversions dans l'ordre inverse de la liste (le dernier
+ * refactoring détecté est inversé en premier) pour gérer correctement
+ * les chaînes de renommage.
+ *
+ * @param branchLines  - Lignes de la branche (ours ou theirs) à inverser
+ * @param refactorings - Liste des refactorings détectés sur cette branche
+ * @returns Lignes avec les refactorings inversés, prêtes pour le merge textuel
+ *
+ * @example
+ * ```ts
+ * const refs = detectRefactorings(baseLines, oursLines);
+ * const oursInverted = invertRefactorings(oursLines, refs);
+ * // oursInverted utilise maintenant la nomenclature de base
+ * ```
+ */
+export declare function invertRefactorings(branchLines: string[], refactorings: Refactoring[]): string[];
+//# sourceMappingURL=invert.d.ts.map

package/dist/refactoring/invert.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"invert.d.ts","sourceRoot":"","sources":["../../src/refactoring/invert.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAiI/C;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,kBAAkB,CAChC,WAAW,EAAE,MAAM,EAAE,EACrB,YAAY,EAAE,WAAW,EAAE,GAC1B,MAAM,EAAE,CAgBV"}

package/dist/refactoring/invert.js

@@ -0,0 +1,180 @@
+/**
+ * GitWand v2.6 — Inversion de refactorings (expérimental)
+ *
+ * Inverse les refactorings détectés par `detect.ts` pour ramener une branche
+ * à la nomenclature de la version de base avant la résolution textuelle.
+ *
+ * ## Rôle dans le pipeline RefMerge
+ *
+ * ```
+ * base ──────────────────────────────────────────────────────┐
+ *        ↘ (refactorings ours)                               │
+ * ours ──→ invertRefactorings(ours, refs_ours) ──→ ours'     ├─→ merge textuel → merged'
+ *        ↘ (refactorings theirs)                             │
+ * theirs → invertRefactorings(theirs, refs_theirs) → theirs' ┘
+ * ```
+ *
+ * Après inversion, `ours'` et `theirs'` utilisent la même nomenclature que
+ * `base`, ce qui rend le merge textuel robuste aux conflits de renommage.
+ *
+ * ## Algorithme
+ *
+ * Pour chaque `Refactoring` dans la liste :
+ * - `rename-local`     : remplacer `newName` → `oldName` dans la portée (`scope`)
+ * - `rename-top-level` : remplacer `newName` → `oldName` dans tout le fichier
+ * - `move-method`      : aucune inversion textuelle possible à ce stade
+ *                        (la méthode est déjà dans la classe cible — on laisse)
+ *
+ * ## Garanties
+ * - Retourne les lignes inchangées si la liste de refactorings est vide.
+ * - Retourne les lignes inchangées en cas d'erreur (safe by default).
+ * - Zéro import Node.js — compatible browser, Node.js, Tauri WebView.
+ */
+// ─── Utilitaires ──────────────────────────────────────────────────────────────
+/** Échappe les caractères spéciaux pour une utilisation dans un RegExp. */
+function escapeRegex(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/**
+ * Remplace toutes les occurrences d'un identifiant dans un texte,
+ * en respectant les limites de mots (`\b`) pour éviter les substitutions partielles.
+ *
+ * @param text    - Texte source
+ * @param oldName - Identifiant à remplacer
+ * @param newName - Identifiant de remplacement
+ * @returns Texte avec les substitutions appliquées
+ */
+function replaceIdentifier(text, oldName, newName) {
+    const pattern = new RegExp(`\\b${escapeRegex(oldName)}\\b`, "g");
+    return text.replace(pattern, newName);
+}
+/**
+ * Détermine si une ligne fait partie de la portée d'une fonction donnée.
+ *
+ * Heuristique : la portée commence à la dernière occurrence de la déclaration
+ * de `scope` avant la ligne, et s'étend jusqu'à ce que la profondeur des
+ * accolades revienne au niveau d'entrée.
+ *
+ * Cette implémentation opère sur le texte complet (join des lignes) et retourne
+ * une paire `[start, end]` d'indices de caractères délimitant la portée.
+ *
+ * Retourne `null` si la portée ne peut pas être localisée.
+ */
+function findScopeRange(text, scope) {
+    // Chercher la déclaration de la portée
+    const scopePattern = new RegExp(`(?:async\\s+)?function\\s+${escapeRegex(scope)}\\s*\\(` +
+        `|(?:const|let|var)\\s+${escapeRegex(scope)}\\s*=`, "g");
+    const match = scopePattern.exec(text);
+    if (!match)
+        return null;
+    const start = match.index;
+    let depth = 0;
+    let inScope = false;
+    let scopeStart = start;
+    let scopeEnd = text.length;
+    for (let i = start; i < text.length; i++) {
+        const ch = text[i];
+        if (ch === "{") {
+            if (!inScope) {
+                inScope = true;
+                scopeStart = i;
+                depth = 1;
+            }
+            else {
+                depth++;
+            }
+        }
+        else if (ch === "}" && inScope) {
+            depth--;
+            if (depth === 0) {
+                scopeEnd = i + 1;
+                break;
+            }
+        }
+    }
+    if (!inScope)
+        return null;
+    // Return range from the function keyword (not just the body `{`) so that
+    // parameter names in the signature are also included in the replacement.
+    return [start, scopeEnd];
+}
+// ─── Inversion d'un refactoring ───────────────────────────────────────────────
+/**
+ * Inverse un seul refactoring dans le texte complet du fichier.
+ *
+ * @param text        - Contenu courant du fichier (branche à inverser)
+ * @param refactoring - Refactoring à inverser
+ * @returns Texte avec le refactoring inversé
+ */
+function invertOne(text, refactoring) {
+    const { kind, oldName, newName, scope } = refactoring;
+    switch (kind) {
+        case "rename-top-level": {
+            // Substitution globale : newName → oldName dans tout le fichier
+            if (!newName)
+                return text;
+            return replaceIdentifier(text, newName, oldName);
+        }
+        case "rename-local": {
+            // Substitution limitée à la portée `scope` si disponible
+            if (!newName)
+                return text;
+            if (!scope) {
+                // Pas de portée connue → substitution globale (plus conservative)
+                return replaceIdentifier(text, newName, oldName);
+            }
+            // Localiser la portée dans le texte
+            const range = findScopeRange(text, scope);
+            if (!range) {
+                // Portée introuvable → substitution globale (dégradation sûre)
+                return replaceIdentifier(text, newName, oldName);
+            }
+            const [scopeStart, scopeEnd] = range;
+            const before = text.slice(0, scopeStart);
+            const inside = text.slice(scopeStart, scopeEnd);
+            const after = text.slice(scopeEnd);
+            return before + replaceIdentifier(inside, newName, oldName) + after;
+        }
+        case "move-method": {
+            // Pas d'inversion textuelle : la méthode est déjà dans la nouvelle classe.
+            // L'orchestrateur gère ce cas différemment (merge structurel de la méthode).
+            return text;
+        }
+    }
+}
+// ─── API publique ─────────────────────────────────────────────────────────────
+/**
+ * Inverse une liste de refactorings dans les lignes d'une branche.
+ *
+ * Applique les inversions dans l'ordre inverse de la liste (le dernier
+ * refactoring détecté est inversé en premier) pour gérer correctement
+ * les chaînes de renommage.
+ *
+ * @param branchLines  - Lignes de la branche (ours ou theirs) à inverser
+ * @param refactorings - Liste des refactorings détectés sur cette branche
+ * @returns Lignes avec les refactorings inversés, prêtes pour le merge textuel
+ *
+ * @example
+ * ```ts
+ * const refs = detectRefactorings(baseLines, oursLines);
+ * const oursInverted = invertRefactorings(oursLines, refs);
+ * // oursInverted utilise maintenant la nomenclature de base
+ * ```
+ */
+export function invertRefactorings(branchLines, refactorings) {
+    try {
+        if (refactorings.length === 0)
+            return branchLines;
+        let text = branchLines.join("\n");
+        // Appliquer les inversions en ordre inverse
+        for (let i = refactorings.length - 1; i >= 0; i--) {
+            text = invertOne(text, refactorings[i]);
+        }
+        return text.split("\n");
+    }
+    catch {
+        // Dégradation silencieuse — retourner les lignes inchangées
+        return branchLines;
+    }
+}
+//# sourceMappingURL=invert.js.map

package/dist/refactoring/invert.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"invert.js","sourceRoot":"","sources":["../../src/refactoring/invert.ts"],"names":[],"mappings":"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"}

package/dist/refactoring/orchestration.d.ts

@@ -0,0 +1,65 @@
+/**
+ * GitWand v2.6 — Pipeline RefMerge (expérimental)
+ *
+ * Orchestre la détection, inversion, merge textuel et rejeu des refactorings
+ * pour résoudre des conflits causés par des renommages concurrents.
+ *
+ * ## Pipeline complet
+ *
+ * ```
+ * input (base, ours, theirs)
+ *   ↓
+ * detectRefactorings(base, ours)  → oursRefs
+ * detectRefactorings(base, theirs) → theirsRefs
+ *   ↓
+ * si quota dépassé → abort (renvoyer null — trop risqué)
+ *   ↓
+ * ours'   = invertRefactorings(ours,   oursRefs)
+ * theirs' = invertRefactorings(theirs, theirsRefs)
+ *   ↓
+ * merge textuel sur (base, ours', theirs') → merged'
+ *   ↓
+ * si merge textuel échoue → abort (renvoyer null)
+ *   ↓
+ * merged = replayRefactorings(merged', mergeRefactorings(oursRefs, theirsRefs))
+ *   ↓
+ * return { lines: merged, oursRefs, theirsRefs }
+ * ```
+ *
+ * ## Garanties
+ * - Retourne `null` si aucun refactoring détecté ou si le pipeline échoue.
+ * - Retourne `null` en cas d'erreur (never throws — safe by default).
+ * - Zéro import Node.js — compatible browser, Node.js, Tauri WebView.
+ */
+import type { ClassifyInput, Refactoring } from "../types.js";
+/** Résultat du pipeline RefMerge pour un hunk. */
+export interface RefMergeResult {
+    /** Lignes résolues après inversion + merge + rejeu. `null` si le pipeline a échoué. */
+    lines: string[] | null;
+    /** Raison de la résolution ou de l'échec. */
+    reason: string;
+    /** Refactorings détectés sur la branche ours (peut être vide). */
+    oursRefs: Refactoring[];
+    /** Refactorings détectés sur la branche theirs (peut être vide). */
+    theirsRefs: Refactoring[];
+}
+/**
+ * Tente de résoudre un hunk via le pipeline RefMerge.
+ *
+ * @param input           - Hunk d'entrée (oursLines, baseLines, theirsLines)
+ * @param maxRefactorings - Nombre maximum de refactorings autorisés par branche
+ * @returns Résultat du pipeline, ou `{ lines: null, ... }` si le pipeline échoue
+ *
+ * @example
+ * ```ts
+ * const result = tryRefMerge(
+ *   { oursLines: [...], baseLines: [...], theirsLines: [...], startLine: 1, endLine: 10 },
+ *   10,
+ * );
+ * if (result.lines !== null) {
+ *   // La résolution RefMerge a réussi
+ * }
+ * ```
+ */
+export declare function tryRefMerge(input: ClassifyInput, maxRefactorings?: number): RefMergeResult;
+//# sourceMappingURL=orchestration.d.ts.map

package/dist/refactoring/orchestration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"orchestration.d.ts","sourceRoot":"","sources":["../../src/refactoring/orchestration.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAQ9D,kDAAkD;AAClD,MAAM,WAAW,cAAc;IAC7B,uFAAuF;IACvF,KAAK,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;IACvB,6CAA6C;IAC7C,MAAM,EAAE,MAAM,CAAC;IACf,kEAAkE;IAClE,QAAQ,EAAE,WAAW,EAAE,CAAC;IACxB,oEAAoE;IACpE,UAAU,EAAE,WAAW,EAAE,CAAC;CAC3B;AA6CD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,WAAW,CACzB,KAAK,EAAE,aAAa,EACpB,eAAe,SAAK,GACnB,cAAc,CA0EhB"}

package/dist/refactoring/orchestration.js

@@ -0,0 +1,174 @@
+/**
+ * GitWand v2.6 — Pipeline RefMerge (expérimental)
+ *
+ * Orchestre la détection, inversion, merge textuel et rejeu des refactorings
+ * pour résoudre des conflits causés par des renommages concurrents.
+ *
+ * ## Pipeline complet
+ *
+ * ```
+ * input (base, ours, theirs)
+ *   ↓
+ * detectRefactorings(base, ours)  → oursRefs
+ * detectRefactorings(base, theirs) → theirsRefs
+ *   ↓
+ * si quota dépassé → abort (renvoyer null — trop risqué)
+ *   ↓
+ * ours'   = invertRefactorings(ours,   oursRefs)
+ * theirs' = invertRefactorings(theirs, theirsRefs)
+ *   ↓
+ * merge textuel sur (base, ours', theirs') → merged'
+ *   ↓
+ * si merge textuel échoue → abort (renvoyer null)
+ *   ↓
+ * merged = replayRefactorings(merged', mergeRefactorings(oursRefs, theirsRefs))
+ *   ↓
+ * return { lines: merged, oursRefs, theirsRefs }
+ * ```
+ *
+ * ## Garanties
+ * - Retourne `null` si aucun refactoring détecté ou si le pipeline échoue.
+ * - Retourne `null` en cas d'erreur (never throws — safe by default).
+ * - Zéro import Node.js — compatible browser, Node.js, Tauri WebView.
+ */
+import { mergeNonOverlapping } from "../diff.js";
+import { detectRefactorings } from "./detect.js";
+import { invertRefactorings } from "./invert.js";
+import { replayRefactorings, mergeRefactorings } from "./replay.js";
+// ─── Merge textuel sur les versions inversées ─────────────────────────────────
+/**
+ * Tente un merge textuel simple entre base, ours' et theirs'.
+ *
+ * Essaie dans l'ordre :
+ * 1. same_change   : ours' === theirs' → prendre ours'
+ * 2. one_side_ours : theirs' === base  → prendre ours'
+ * 3. one_side_they : ours' === base    → prendre theirs'
+ * 4. non_overlapping : essayer `mergeNonOverlapping(base, ours', theirs')`
+ *
+ * @returns Les lignes fusionnées, ou `null` si chevauchement résiduel.
+ */
+function mergeInverted(base, oursInverted, theirsInverted) {
+    const oursText = oursInverted.join("\n");
+    const theirsText = theirsInverted.join("\n");
+    const baseText = base.join("\n");
+    // 1. same_change : les deux versions inversées sont identiques
+    if (oursText === theirsText) {
+        return [...oursInverted];
+    }
+    // 2. one_side_change : theirs' == base → prendre ours'
+    if (theirsText === baseText) {
+        return [...oursInverted];
+    }
+    // 3. one_side_change : ours' == base → prendre theirs'
+    if (oursText === baseText) {
+        return [...theirsInverted];
+    }
+    // 4. Tentative de merge non-overlapping (les changements résiduels ne se chevauchent pas)
+    return mergeNonOverlapping(base, oursInverted, theirsInverted);
+}
+// ─── Pipeline principal ───────────────────────────────────────────────────────
+/**
+ * Tente de résoudre un hunk via le pipeline RefMerge.
+ *
+ * @param input           - Hunk d'entrée (oursLines, baseLines, theirsLines)
+ * @param maxRefactorings - Nombre maximum de refactorings autorisés par branche
+ * @returns Résultat du pipeline, ou `{ lines: null, ... }` si le pipeline échoue
+ *
+ * @example
+ * ```ts
+ * const result = tryRefMerge(
+ *   { oursLines: [...], baseLines: [...], theirsLines: [...], startLine: 1, endLine: 10 },
+ *   10,
+ * );
+ * if (result.lines !== null) {
+ *   // La résolution RefMerge a réussi
+ * }
+ * ```
+ */
+export function tryRefMerge(input, maxRefactorings = 10) {
+    try {
+        const { oursLines, baseLines, theirsLines } = input;
+        // Cas trivial : pas de base → le pipeline ne peut pas fonctionner
+        if (baseLines.length === 0) {
+            return {
+                lines: null,
+                reason: "RefMerge : base vide (diff2 uniquement) — pipeline inapplicable.",
+                oursRefs: [],
+                theirsRefs: [],
+            };
+        }
+        // ── Phase 1 : Détection ─────────────────────────────────────────────────
+        const oursRefs = detectRefactorings(baseLines, oursLines, maxRefactorings);
+        const theirsRefs = detectRefactorings(baseLines, theirsLines, maxRefactorings);
+        // Si aucun refactoring détecté → laisser le pipeline standard gérer
+        if (oursRefs.length === 0 && theirsRefs.length === 0) {
+            return {
+                lines: null,
+                reason: "RefMerge : aucun refactoring détecté — fallback au pipeline standard.",
+                oursRefs: [],
+                theirsRefs: [],
+            };
+        }
+        // Si quota dépassé de chaque côté → trop risqué, abandonner
+        if (oursRefs.length >= maxRefactorings || theirsRefs.length >= maxRefactorings) {
+            return {
+                lines: null,
+                reason: `RefMerge : quota atteint (ours: ${oursRefs.length}, theirs: ${theirsRefs.length}) — fallback au pipeline standard.`,
+                oursRefs,
+                theirsRefs,
+            };
+        }
+        // ── Phase 2 : Inversion ─────────────────────────────────────────────────
+        const oursInverted = invertRefactorings(oursLines, oursRefs);
+        const theirsInverted = invertRefactorings(theirsLines, theirsRefs);
+        // ── Phase 3 : Merge textuel sur les versions inversées ──────────────────
+        const mergedInverted = mergeInverted(baseLines, oursInverted, theirsInverted);
+        if (mergedInverted === null) {
+            return {
+                lines: null,
+                reason: "RefMerge : chevauchement résiduel après inversion — fallback au pipeline standard.",
+                oursRefs,
+                theirsRefs,
+            };
+        }
+        // ── Phase 4 : Rejeu ─────────────────────────────────────────────────────
+        const allRefs = mergeRefactorings(oursRefs, theirsRefs);
+        const finalLines = replayRefactorings(mergedInverted, allRefs);
+        const summary = summarizeRefs(oursRefs, theirsRefs);
+        return {
+            lines: finalLines,
+            reason: `RefMerge : ${summary} — résolution par inversion+merge+rejeu.`,
+            oursRefs,
+            theirsRefs,
+        };
+    }
+    catch {
+        // Dégradation silencieuse — jamais crasher le pipeline principal
+        return {
+            lines: null,
+            reason: "RefMerge : erreur interne — fallback au pipeline standard.",
+            oursRefs: [],
+            theirsRefs: [],
+        };
+    }
+}
+// ─── Utilitaires ──────────────────────────────────────────────────────────────
+/** Produit un résumé compact des refactorings pour le trace. */
+function summarizeRefs(oursRefs, theirsRefs) {
+    const parts = [];
+    const allRefs = [...oursRefs, ...theirsRefs];
+    const renames = allRefs.filter((r) => r.kind !== "move-method");
+    const moves = allRefs.filter((r) => r.kind === "move-method");
+    if (renames.length > 0) {
+        const sample = renames
+            .slice(0, 2)
+            .map((r) => `${r.oldName}→${r.newName ?? "?"}`)
+            .join(", ");
+        parts.push(`${renames.length} rename(s) [${sample}${renames.length > 2 ? "…" : ""}]`);
+    }
+    if (moves.length > 0) {
+        parts.push(`${moves.length} move-method(s)`);
+    }
+    return parts.join(", ");
+}
+//# sourceMappingURL=orchestration.js.map

package/dist/refactoring/orchestration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"orchestration.js","sourceRoot":"","sources":["../../src/refactoring/orchestration.ts"],"names":[],"mappings":"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"}

package/dist/refactoring/replay.d.ts

@@ -0,0 +1,74 @@
+/**
+ * GitWand v2.6 — Rejeu de refactorings (expérimental)
+ *
+ * Rejoue les refactorings sur le résultat du merge textuel pour produire
+ * la sortie finale RefMerge.
+ *
+ * ## Rôle dans le pipeline RefMerge
+ *
+ * ```
+ * merged' (résultat du merge textuel sur les branches inversées)
+ *    │
+ *    ↓ replayRefactorings(merged', refs_ours ∪ refs_theirs)
+ *    │
+ * merged (sortie finale — nomenclature de la branche qui a renommé)
+ * ```
+ *
+ * ## Stratégie de rejeu
+ *
+ * Quand ours et theirs ont tous deux renommé le même symbole (ex: `x` → `y`
+ * des deux côtés), le rejeu est simple : appliquer une fois.
+ *
+ * Quand ours et theirs ont renommé différemment (ex: ours `x` → `y`,
+ * theirs `x` → `z`), c'est un conflit de renommage réel. Le pipeline
+ * RefMerge préfère le renommage de **ours** dans ce cas (comportement
+ * analogue à `prefer-ours` pour les renommages). Le conflit résiduel est
+ * tracé dans le `DecisionTrace` par l'orchestrateur.
+ *
+ * ## Algorithme
+ *
+ * Pour chaque `Refactoring` dans la liste (dédupliquée) :
+ * - `rename-local`     : remplacer `oldName` → `newName` dans la portée
+ * - `rename-top-level` : remplacer `oldName` → `newName` dans tout le texte
+ * - `move-method`      : no-op (déjà géré par le merge structurel)
+ *
+ * ## Garanties
+ * - Retourne les lignes inchangées si la liste est vide.
+ * - Retourne les lignes inchangées en cas d'erreur (safe by default).
+ * - Zéro import Node.js — compatible browser, Node.js, Tauri WebView.
+ */
+import type { Refactoring } from "../types.js";
+/**
+ * Déduplique et fusionne deux listes de refactorings (ours + theirs).
+ *
+ * Règles :
+ * 1. Si ours et theirs ont le même `(kind, oldName, newName)` → garder une copie.
+ * 2. Si ours et theirs ont renommé le même `oldName` différemment →
+ *    préférer ours (comportement `prefer-ours` pour les renommages).
+ * 3. Les refactorings sans conflit des deux côtés sont tous inclus.
+ * 4. Les `move-method` sont inclus sans déduplication (clé = `oldName + sourceClass`).
+ *
+ * @returns Liste déduplicée, avec les refactorings ours prioritaires en cas de conflit.
+ */
+export declare function mergeRefactorings(oursRefs: Refactoring[], theirsRefs: Refactoring[]): Refactoring[];
+/**
+ * Rejoue une liste de refactorings sur les lignes du résultat de merge.
+ *
+ * Applique les refactorings dans leur ordre naturel (premier détecté =
+ * premier rejoué), ce qui est l'inverse de l'ordre d'inversion.
+ * Cette symétrie garantit que `replay(invert(branch, refs), refs) ≈ branch`
+ * à isomorphisme de merge près.
+ *
+ * @param mergedLines  - Lignes du résultat du merge textuel (base inversée)
+ * @param refactorings - Liste des refactorings à rejouer (déjà déduplicée)
+ * @returns Lignes avec les refactorings réappliqués, prêtes comme sortie finale
+ *
+ * @example
+ * ```ts
+ * const refs = mergeRefactorings(oursRefs, theirsRefs);
+ * const finalLines = replayRefactorings(mergedLines, refs);
+ * // finalLines utilise la nomenclature finale (post-refactoring)
+ * ```
+ */
+export declare function replayRefactorings(mergedLines: string[], refactorings: Refactoring[]): string[];
+//# sourceMappingURL=replay.d.ts.map

package/dist/refactoring/replay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"replay.d.ts","sourceRoot":"","sources":["../../src/refactoring/replay.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AA+D/C;;;;;;;;;;;GAWG;AACH,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,WAAW,EAAE,EACvB,UAAU,EAAE,WAAW,EAAE,GACxB,WAAW,EAAE,CAqBf;AAmDD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,kBAAkB,CAChC,WAAW,EAAE,MAAM,EAAE,EACrB,YAAY,EAAE,WAAW,EAAE,GAC1B,MAAM,EAAE,CAeV"}