@gitwand/core 2.5.0 → 2.6.0

package/dist/patterns/refactoring-aware-merge.d.ts

@@ -0,0 +1,52 @@
+/**
+ * v2.6 — Pattern refactoring-aware-merge (priority 25, expérimental, opt-in).
+ *
+ * Détecte les conflits causés par des refactorings concurrents (renommages,
+ * déplacements de méthode) et délègue la résolution au pipeline RefMerge.
+ *
+ * ## Position dans la hiérarchie
+ *
+ * Priority 25 — après les patterns trivials (1–10) mais avant les patterns
+ * heuristiques (whitespace: 5, value_only: 8, non_overlapping: 4). En pratique,
+ * ce pattern n'est évalué que sur les hunks qui ont déjà résisté aux patterns
+ * plus simples, car ceux-ci ont une priorité inférieure (numéro plus petit).
+ *
+ * Attendez — la convention est : **plus petit = évalué en premier**. Donc 25
+ * signifie évalué AVANT whitespace_only (5) ? Non — whitespace (5) est évalué
+ * avant RefMerge (25). Les patterns à faible numéro sont prioritaires.
+ *
+ * RefMerge à priority 25 est évalué :
+ * - APRÈS non_overlapping (4), whitespace_only (5), reorder_only (6),
+ *   insertion_at_boundary (7), value_only_change (8)
+ * - AVANT complex (999) et llm_proposed (998)
+ *
+ * C'est intentionnel : on ne tente RefMerge que si les patterns textuels simples
+ * n'ont pas suffi, car RefMerge est plus coûteux (tokenisation + détection).
+ *
+ * ## Activation
+ *
+ * Ce pattern est désactivé par défaut. Il s'active via `setRefMergeEnabled(true)`
+ * appelé par `resolve()` quand `options.refactoringAware.enabled === true`.
+ * Le flag est réinitialisé après chaque appel à `resolve()`.
+ *
+ * ## Résolution
+ *
+ * `detect()` exécute le pipeline RefMerge complet et cache le résultat dans
+ * `_lastResult`. Si le pipeline réussit (`lines !== null`), detect retourne `true`
+ * et `assembleResolution()` peut récupérer les lignes via `getLastRefMergeResult()`.
+ */
+import type { PatternPlugin } from "../types.js";
+import type { RefMergeResult } from "../refactoring/orchestration.js";
+/** Active ou désactive le pattern RefMerge pour la prochaine résolution. */
+export declare function setRefMergeEnabled(enabled: boolean, max?: number): void;
+/** Retourne l'état d'activation courant (utile pour les tests). */
+export declare function isRefMergeEnabled(): boolean;
+/**
+ * Retourne le dernier résultat RefMerge mis en cache par `detect()`.
+ * Appelé par `assembleResolution()` pour récupérer les lignes sans recalcul.
+ * Retourne `null` si `detect()` n'a pas encore été appelé ou si le résultat a été reset.
+ */
+export declare function getLastRefMergeResult(): RefMergeResult | null;
+declare const refactoringAwareMerge: PatternPlugin;
+export default refactoringAwareMerge;
+//# sourceMappingURL=refactoring-aware-merge.d.ts.map

package/dist/patterns/refactoring-aware-merge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"refactoring-aware-merge.d.ts","sourceRoot":"","sources":["../../src/patterns/refactoring-aware-merge.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAEH,OAAO,KAAK,EAAkC,aAAa,EAAE,MAAM,aAAa,CAAC;AAGjF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AAatE,4EAA4E;AAC5E,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,OAAO,EAAE,GAAG,SAAK,GAAG,IAAI,CAInE;AAED,mEAAmE;AACnE,wBAAgB,iBAAiB,IAAI,OAAO,CAE3C;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,IAAI,cAAc,GAAG,IAAI,CAE7D;AAID,QAAA,MAAM,qBAAqB,EAAE,aAyE5B,CAAC;AAEF,eAAe,qBAAqB,CAAC"}

package/dist/patterns/refactoring-aware-merge.js

@@ -0,0 +1,131 @@
+/**
+ * v2.6 — Pattern refactoring-aware-merge (priority 25, expérimental, opt-in).
+ *
+ * Détecte les conflits causés par des refactorings concurrents (renommages,
+ * déplacements de méthode) et délègue la résolution au pipeline RefMerge.
+ *
+ * ## Position dans la hiérarchie
+ *
+ * Priority 25 — après les patterns trivials (1–10) mais avant les patterns
+ * heuristiques (whitespace: 5, value_only: 8, non_overlapping: 4). En pratique,
+ * ce pattern n'est évalué que sur les hunks qui ont déjà résisté aux patterns
+ * plus simples, car ceux-ci ont une priorité inférieure (numéro plus petit).
+ *
+ * Attendez — la convention est : **plus petit = évalué en premier**. Donc 25
+ * signifie évalué AVANT whitespace_only (5) ? Non — whitespace (5) est évalué
+ * avant RefMerge (25). Les patterns à faible numéro sont prioritaires.
+ *
+ * RefMerge à priority 25 est évalué :
+ * - APRÈS non_overlapping (4), whitespace_only (5), reorder_only (6),
+ *   insertion_at_boundary (7), value_only_change (8)
+ * - AVANT complex (999) et llm_proposed (998)
+ *
+ * C'est intentionnel : on ne tente RefMerge que si les patterns textuels simples
+ * n'ont pas suffi, car RefMerge est plus coûteux (tokenisation + détection).
+ *
+ * ## Activation
+ *
+ * Ce pattern est désactivé par défaut. Il s'active via `setRefMergeEnabled(true)`
+ * appelé par `resolve()` quand `options.refactoringAware.enabled === true`.
+ * Le flag est réinitialisé après chaque appel à `resolve()`.
+ *
+ * ## Résolution
+ *
+ * `detect()` exécute le pipeline RefMerge complet et cache le résultat dans
+ * `_lastResult`. Si le pipeline réussit (`lines !== null`), detect retourne `true`
+ * et `assembleResolution()` peut récupérer les lignes via `getLastRefMergeResult()`.
+ */
+import { makeScore, scopeImpact } from "./utils.js";
+import { tryRefMerge } from "../refactoring/orchestration.js";
+// ─── État module ──────────────────────────────────────────────────────────────
+/** Flag d'activation — positionné par `resolve()` */
+let _refMergeEnabled = false;
+/** Quota maximum de refactorings par branche */
+let _maxRefactoringsPerSide = 10;
+/** Dernier résultat RefMerge (cache pour éviter un double calcul detect+assemble) */
+let _lastResult = null;
+// ─── API d'activation (consommée par resolver/index.ts) ──────────────────────
+/** Active ou désactive le pattern RefMerge pour la prochaine résolution. */
+export function setRefMergeEnabled(enabled, max = 10) {
+    _refMergeEnabled = enabled;
+    _maxRefactoringsPerSide = max;
+    _lastResult = null; // reset cache
+}
+/** Retourne l'état d'activation courant (utile pour les tests). */
+export function isRefMergeEnabled() {
+    return _refMergeEnabled;
+}
+/**
+ * Retourne le dernier résultat RefMerge mis en cache par `detect()`.
+ * Appelé par `assembleResolution()` pour récupérer les lignes sans recalcul.
+ * Retourne `null` si `detect()` n'a pas encore été appelé ou si le résultat a été reset.
+ */
+export function getLastRefMergeResult() {
+    return _lastResult;
+}
+// ─── Plugin ───────────────────────────────────────────────────────────────────
+const refactoringAwareMerge = {
+    type: "refactoring_aware_merge",
+    /**
+     * Priority 970 — évalué après tous les patterns textuels (10–60) mais avant
+     * llm_proposed (998) et complex (999). RefMerge est un recours pour les hunks
+     * que tous les patterns simples ont échoué à résoudre.
+     */
+    priority: 970,
+    /**
+     * Nécessite la base (diff3) pour détecter correctement les refactorings.
+     * Sans base, impossible de calculer ce qui a changé de chaque côté.
+     */
+    requires: "diff3",
+    detect(h) {
+        if (!_refMergeEnabled)
+            return false;
+        if (h.baseLines.length === 0)
+            return false;
+        // Exécuter le pipeline RefMerge complet et cacher le résultat
+        const result = tryRefMerge(h, _maxRefactoringsPerSide);
+        _lastResult = result;
+        return result.lines !== null;
+    },
+    confidence(h) {
+        return makeScore(82, // typeClassification : refactoring bijectivement vérifié + merge réussi
+        12, // dataRisk : faible — merge déterministe, pas génératif
+        scopeImpact(h.oursLines.length + h.theirsLines.length), [
+            "Refactoring bijectivement vérifié (substitution simulée)",
+            "Merge textuel réussi sur les versions inversées",
+        ], []);
+    },
+    explanation(_h) {
+        if (_lastResult) {
+            const refs = [..._lastResult.oursRefs, ..._lastResult.theirsRefs];
+            const renames = refs.filter((r) => r.kind !== "move-method");
+            const moves = refs.filter((r) => r.kind === "move-method");
+            const parts = [];
+            if (renames.length > 0) {
+                parts.push(`${renames.length} renommage(s) détecté(s) et inversé(s)`);
+            }
+            if (moves.length > 0) {
+                parts.push(`${moves.length} déplacement(s) de méthode`);
+            }
+            return `Conflit de refactoring — ${parts.join(", ") || "refactoring détecté"}. Résolu via le pipeline RefMerge (inversion + merge + rejeu).`;
+        }
+        return "Conflit causé par un refactoring concurrent — résolu via le pipeline RefMerge.";
+    },
+    passReason(_h) {
+        if (_lastResult?.oursRefs.length || _lastResult?.theirsRefs.length) {
+            return `Refactoring(s) détecté(s) : ours=${_lastResult.oursRefs.length}, theirs=${_lastResult.theirsRefs.length}. Merge textuel réussi après inversion.`;
+        }
+        return "Refactoring bijectivement détecté — merge réussi après inversion.";
+    },
+    failReason(_h) {
+        if (!_refMergeEnabled) {
+            return "RefMerge désactivé (options.refactoringAware.enabled !== true).";
+        }
+        if (_lastResult && _lastResult.lines === null) {
+            return `RefMerge échoué : ${_lastResult.reason}`;
+        }
+        return "Aucun refactoring bijectivement détectable dans ce hunk.";
+    },
+};
+export default refactoringAwareMerge;
+//# sourceMappingURL=refactoring-aware-merge.js.map

package/dist/patterns/refactoring-aware-merge.js.map

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

package/dist/refactoring/detect.d.ts

@@ -0,0 +1,54 @@
+/**
+ * GitWand v2.6 — Détection de refactorings (expérimental)
+ *
+ * Détecte les refactorings entre la version de base d'un fichier et une branche
+ * (ours ou theirs). Utilisé par le pipeline RefMerge avant la résolution textuelle.
+ *
+ * ## Algorithme
+ *
+ * La détection est **purement textuelle** (zero dépendance, compatible browser) :
+ *
+ * ### rename-local / rename-top-level
+ * 1. Tokeniser base et branch en listes d'identifiants (sans mots-clés).
+ * 2. Identifier les tokens présents uniquement dans base (`removed`) et
+ *    uniquement dans branch (`added`).
+ * 3. Pour chaque paire (oldName, newName) dont le compte d'occurrences est
+ *    identique ET unique dans le groupe, construire une substitution candidate.
+ * 4. Appliquer toutes les substitutions simultanément sur la séquence base.
+ * 5. Si la séquence obtenue == séquence branch : les renames sont confirmés.
+ * 6. Classifier rename-local vs rename-top-level selon le contexte syntaxique.
+ *
+ * ### move-method
+ * Parser léger ligne par ligne pour extraire `Map<className → Set<methodName>>`.
+ * Détecter les méthodes ayant changé de classe entre base et branch.
+ *
+ * ## Garanties
+ * - Retourne `[]` en cas d'erreur ou d'absence de tree-sitter (safe by default).
+ * - Zéro import Node.js — compatible browser, Node.js, Tauri WebView.
+ * - Complexité O(n) sur la longueur du code (n = nombre de tokens).
+ */
+import type { Refactoring } from "../types.js";
+/**
+ * Détecte les refactorings entre la version de base d'un fichier et une branche.
+ *
+ * Point d'entrée principal du module. Appelé deux fois par l'orchestrateur
+ * RefMerge — une fois pour `(base, ours)`, une fois pour `(base, theirs)`.
+ *
+ * @param baseLines       Lignes du fichier dans la version de base (ancêtre commun)
+ * @param branchLines     Lignes du fichier dans la branche (ours ou theirs)
+ * @param maxRefactorings Quota maximum de refactorings retournés (défaut: 10)
+ * @returns               Liste des refactorings détectés, triée par type de confiance
+ *                        (rename-top-level > rename-local > move-method).
+ *                        Retourne `[]` en cas d'erreur ou si aucun refactoring détecté.
+ *
+ * @example
+ * ```ts
+ * const refs = detectRefactorings(
+ *   ["function foo(x) { return x + 1; }"],
+ *   ["function foo(value) { return value + 1; }"],
+ * );
+ * // refs = [{ kind: "rename-local", oldName: "x", newName: "value", scope: "foo" }]
+ * ```
+ */
+export declare function detectRefactorings(baseLines: string[], branchLines: string[], maxRefactorings?: number): Refactoring[];
+//# sourceMappingURL=detect.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"detect.d.ts","sourceRoot":"","sources":["../../src/refactoring/detect.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAoX/C;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,MAAM,EAAE,EACnB,WAAW,EAAE,MAAM,EAAE,EACrB,eAAe,SAAK,GACnB,WAAW,EAAE,CA2Bf"}

package/dist/refactoring/detect.js

@@ -0,0 +1,389 @@
+/**
+ * GitWand v2.6 — Détection de refactorings (expérimental)
+ *
+ * Détecte les refactorings entre la version de base d'un fichier et une branche
+ * (ours ou theirs). Utilisé par le pipeline RefMerge avant la résolution textuelle.
+ *
+ * ## Algorithme
+ *
+ * La détection est **purement textuelle** (zero dépendance, compatible browser) :
+ *
+ * ### rename-local / rename-top-level
+ * 1. Tokeniser base et branch en listes d'identifiants (sans mots-clés).
+ * 2. Identifier les tokens présents uniquement dans base (`removed`) et
+ *    uniquement dans branch (`added`).
+ * 3. Pour chaque paire (oldName, newName) dont le compte d'occurrences est
+ *    identique ET unique dans le groupe, construire une substitution candidate.
+ * 4. Appliquer toutes les substitutions simultanément sur la séquence base.
+ * 5. Si la séquence obtenue == séquence branch : les renames sont confirmés.
+ * 6. Classifier rename-local vs rename-top-level selon le contexte syntaxique.
+ *
+ * ### move-method
+ * Parser léger ligne par ligne pour extraire `Map<className → Set<methodName>>`.
+ * Détecter les méthodes ayant changé de classe entre base et branch.
+ *
+ * ## Garanties
+ * - Retourne `[]` en cas d'erreur ou d'absence de tree-sitter (safe by default).
+ * - Zéro import Node.js — compatible browser, Node.js, Tauri WebView.
+ * - Complexité O(n) sur la longueur du code (n = nombre de tokens).
+ */
+// ─── Constantes ───────────────────────────────────────────────────────────────
+/**
+ * Regex des identifiants JavaScript/TypeScript valides.
+ * Capture les noms de variables, fonctions, classes, paramètres.
+ * Reset de lastIndex requis avant chaque utilisation (flag `g`).
+ */
+const IDENT_RE = /[A-Za-z_$][A-Za-z0-9_$]*/g;
+/**
+ * Mots-clés JS/TS exclus de la détection de renommage.
+ * Un mot-clé ne peut pas être "renommé" — ce serait un faux positif.
+ */
+const KEYWORDS = new Set([
+    "abstract", "any", "as", "async", "await", "bigint", "boolean", "break",
+    "case", "catch", "class", "const", "constructor", "continue", "debugger",
+    "declare", "default", "delete", "do", "else", "enum", "export", "extends",
+    "false", "finally", "for", "from", "function", "get", "if", "implements",
+    "import", "in", "infer", "instanceof", "interface", "intrinsic", "is",
+    "keyof", "let", "module", "namespace", "never", "new", "null", "number",
+    "object", "of", "out", "override", "package", "private", "protected",
+    "public", "readonly", "require", "return", "satisfies", "set", "static",
+    "string", "super", "switch", "symbol", "this", "throw", "true", "try",
+    "type", "typeof", "undefined", "unique", "unknown", "using", "var", "void",
+    "while", "with", "yield",
+]);
+// ─── Utilitaires de tokenisation ─────────────────────────────────────────────
+/**
+ * Extrait la liste ordonnée des identifiants non-mot-clé d'un bloc de code.
+ * L'ordre est préservé — c'est la "séquence de tokens" utilisée pour la
+ * vérification de substitution bijective.
+ */
+function tokenize(lines) {
+    const text = lines.join("\n");
+    const tokens = [];
+    IDENT_RE.lastIndex = 0;
+    let m;
+    while ((m = IDENT_RE.exec(text)) !== null) {
+        const tok = m[0];
+        if (!KEYWORDS.has(tok))
+            tokens.push(tok);
+    }
+    return tokens;
+}
+/** Compte les occurrences de chaque token. */
+function freqMap(tokens) {
+    const map = new Map();
+    for (const tok of tokens)
+        map.set(tok, (map.get(tok) ?? 0) + 1);
+    return map;
+}
+/** Vérifie l'égalité élément par élément de deux tableaux de strings. */
+function arraysEqual(a, b) {
+    if (a.length !== b.length)
+        return false;
+    for (let i = 0; i < a.length; i++) {
+        if (a[i] !== b[i])
+            return false;
+    }
+    return true;
+}
+/** Échappe les caractères spéciaux pour une utilisation dans un RegExp. */
+function escapeRegex(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/**
+ * Génère toutes les permutations d'un tableau de strings.
+ * Utilisé pour résoudre les groupes de renommages ambigus (même count d'occurrences).
+ * Limité à des tableaux de taille ≤ 4 (max 24 permutations) pour éviter l'explosion combinatoire.
+ */
+function permutations(arr) {
+    if (arr.length <= 1)
+        return [[...arr]];
+    const result = [];
+    for (let i = 0; i < arr.length; i++) {
+        const first = arr[i];
+        const rest = [...arr.slice(0, i), ...arr.slice(i + 1)];
+        for (const perm of permutations(rest)) {
+            result.push([first, ...perm]);
+        }
+    }
+    return result;
+}
+/**
+ * Cherche récursivement une assignation valide (substMap) pour les groupes ambigus.
+ * Pour chaque groupe ambigu restant, essaie toutes les permutations de `news`
+ * et valide via la vérification bijective complète.
+ *
+ * @returns La substMap complète si une assignation valide est trouvée, sinon null.
+ */
+function resolveAmbiguous(baseToks, branchToks, current, remaining) {
+    if (remaining.length === 0) {
+        // Vérification bijective finale : toutes les substitutions appliquées simultanément
+        const substituted = baseToks.map((t) => current.get(t) ?? t);
+        return arraysEqual(substituted, branchToks) ? current : null;
+    }
+    const [group, ...rest] = remaining;
+    for (const perm of permutations(group.news)) {
+        const candidate = new Map(current);
+        for (let i = 0; i < group.olds.length; i++) {
+            candidate.set(group.olds[i], perm[i]);
+        }
+        const result = resolveAmbiguous(baseToks, branchToks, candidate, rest);
+        if (result !== null)
+            return result;
+    }
+    return null;
+}
+// ─── Détection de renommages ──────────────────────────────────────────────────
+/**
+ * Détecte les renommages uniformes entre base et branch.
+ *
+ * Algorithme de substitution bijective simultanée :
+ * 1. Tokens présents uniquement dans base → candidats `oldName`.
+ * 2. Tokens présents uniquement dans branch → candidats `newName`.
+ * 3. Grouper par nombre d'occurrences. Un groupe est "non ambigu" ssi
+ *    exactement un oldName et un newName ont ce compte (signal fort).
+ * 4. Appliquer toutes les substitutions simultanément sur baseToks.
+ * 5. Si la séquence résultante == branchToks : tous les renames sont confirmés.
+ *
+ * Cette vérification simultanée gère correctement le cas multi-rename
+ * (ex: deux variables renommées en même temps dans le même hunk).
+ */
+function detectRenames(baseLines, branchLines, max) {
+    const baseToks = tokenize(baseLines);
+    const branchToks = tokenize(branchLines);
+    if (baseToks.length === 0 || branchToks.length === 0)
+        return [];
+    const baseFreq = freqMap(baseToks);
+    const branchFreq = freqMap(branchToks);
+    // Tokens uniquement dans base (disparus → anciens noms candidats)
+    const onlyInBase = [...baseFreq.entries()].filter(([tok]) => !branchFreq.has(tok));
+    // Tokens uniquement dans branch (apparus → nouveaux noms candidats)
+    const onlyInBranch = new Map([...branchFreq.entries()].filter(([tok]) => !baseFreq.has(tok)));
+    if (onlyInBase.length === 0 || onlyInBranch.size === 0)
+        return [];
+    // Grouper par compte d'occurrences pour la correspondance non-ambiguë
+    const byCount = new Map();
+    for (const [tok, cnt] of onlyInBase) {
+        const g = byCount.get(cnt) ?? { old: [], next: [] };
+        g.old.push(tok);
+        byCount.set(cnt, g);
+    }
+    for (const [tok, cnt] of onlyInBranch) {
+        const g = byCount.get(cnt) ?? { old: [], next: [] };
+        g.next.push(tok);
+        byCount.set(cnt, g);
+    }
+    // Construire la map de substitution.
+    // Groupes non-ambigus (1 old → 1 new) : assignation directe.
+    // Groupes ambigus (plusieurs olds/news avec le même count) : on tente toutes
+    // les permutations via resolveAmbiguous() et la vérification bijective finale.
+    const unambiguousMap = new Map();
+    const ambiguousGroups = [];
+    for (const { old, next } of byCount.values()) {
+        if (old.length === 1 && next.length === 1) {
+            unambiguousMap.set(old[0], next[0]);
+        }
+        else if (old.length === next.length && old.length >= 2 && old.length <= 4) {
+            // Même cardinalité — potentiellement bijectif, à résoudre par permutation
+            ambiguousGroups.push({ olds: old, news: next });
+        }
+        // Cardinalités différentes → pas bijectif, ignoré
+    }
+    if (unambiguousMap.size === 0 && ambiguousGroups.length === 0)
+        return [];
+    // Trouver une assignation valide (vérification bijective sur la séquence complète)
+    const substMap = resolveAmbiguous(baseToks, branchToks, unambiguousMap, ambiguousGroups);
+    if (!substMap)
+        return [];
+    // Tous les renames sont confirmés — construire les objets Refactoring
+    const results = [];
+    for (const [oldName, newName] of substMap) {
+        if (results.length >= max)
+            break;
+        const kind = classifyRenameKind(baseLines, oldName);
+        results.push({
+            kind,
+            oldName,
+            newName,
+            scope: kind === "rename-local" ? extractScope(baseLines, oldName) : undefined,
+        });
+    }
+    return results;
+}
+/**
+ * Classifie un renommage en "rename-local" ou "rename-top-level".
+ *
+ * Heuristique : si le symbole apparaît comme nom dans une déclaration
+ * `function X`, `class X`, `async function X`, ou `export function X`
+ * au niveau top-level (début de ligne, indentation minimale), c'est top-level.
+ *
+ * Sinon : on suppose que c'est un renommage local (variable, paramètre).
+ */
+function classifyRenameKind(baseLines, name) {
+    const escapedName = escapeRegex(name);
+    const topLevel = new RegExp(`^[ \\t]{0,2}(?:export\\s+)?(?:default\\s+)?(?:async\\s+)?(?:function|class)\\s+${escapedName}\\b`, "m");
+    const text = baseLines.join("\n");
+    return topLevel.test(text) ? "rename-top-level" : "rename-local";
+}
+/**
+ * Extrait le nom de la fonction englobante (portée) d'un renommage local.
+ *
+ * Utilisé pour remplir `Refactoring.scope` → permet à `invert.ts` de
+ * limiter la substitution inverse à la bonne portée lors du rejeu.
+ *
+ * Stratégie : cherche la dernière déclaration de fonction `function X(`
+ * ou `const X = (` qui précède la première occurrence du symbole renommé.
+ */
+function extractScope(baseLines, name) {
+    const text = baseLines.join("\n");
+    const nameIdx = text.indexOf(name);
+    if (nameIdx === -1)
+        return undefined;
+    const before = text.slice(0, nameIdx);
+    // Pattern 1 : `function X(` ou `async function X(`
+    const funcMatches = [...before.matchAll(/(?:async\s+)?function\s+(\w+)\s*\(/g)];
+    if (funcMatches.length > 0) {
+        return funcMatches[funcMatches.length - 1][1];
+    }
+    // Pattern 2 : `const/let X = (` → arrow function
+    const arrowMatches = [...before.matchAll(/(?:const|let|var)\s+(\w+)\s*=/g)];
+    if (arrowMatches.length > 0) {
+        return arrowMatches[arrowMatches.length - 1][1];
+    }
+    return undefined;
+}
+/**
+ * Parse ligne par ligne pour extraire la carte des méthodes par classe.
+ *
+ * Suit la profondeur des accolades pour déterminer quand on sort d'une classe.
+ * Ne gère pas les classes imbriquées (cas rare, accepté comme limitation).
+ */
+function extractClassMethods(lines) {
+    const result = new Map();
+    let currentClass = null;
+    let braceDepth = 0;
+    let classEntryDepth = -1;
+    for (const line of lines) {
+        // Détecter une déclaration de classe
+        const classMatch = line.match(/^\s{0,4}(?:export\s+)?(?:default\s+)?(?:abstract\s+)?class\s+(\w+)/);
+        if (classMatch && classMatch[1]) {
+            currentClass = classMatch[1];
+            classEntryDepth = braceDepth;
+            if (!result.has(currentClass))
+                result.set(currentClass, new Set());
+        }
+        // Compter les accolades pour suivre la portée
+        for (const ch of line) {
+            if (ch === "{") {
+                braceDepth++;
+            }
+            else if (ch === "}") {
+                braceDepth--;
+                // Si on sort de la profondeur d'entrée de la classe → fin de classe
+                if (currentClass !== null && braceDepth <= classEntryDepth) {
+                    currentClass = null;
+                    classEntryDepth = -1;
+                }
+            }
+        }
+        // Détecter les méthodes dans la classe courante
+        // (indentation > 0, suivi de `name(` avec modificateurs optionnels)
+        if (currentClass !== null) {
+            const methodMatch = line.match(/^\s{2,}(?:(?:public|private|protected|static|async|abstract|override|readonly)\s+)*([A-Za-z_$][A-Za-z0-9_$]*)\s*(?:<[^>]*>)?\s*\(/);
+            if (methodMatch && methodMatch[1]) {
+                const methodName = methodMatch[1];
+                if (!KEYWORDS.has(methodName) && methodName !== "constructor") {
+                    result.get(currentClass).add(methodName);
+                }
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Détecte les déplacements de méthode entre classes.
+ *
+ * Pour chaque méthode présente dans une classe `C` de base :
+ * - Si la méthode a disparu de `C` dans branch ET est apparue dans `D` (D ≠ C) :
+ *   → move-method(method, C → D).
+ */
+function detectMoveMethod(baseLines, branchLines, max) {
+    const baseClasses = extractClassMethods(baseLines);
+    const branchClasses = extractClassMethods(branchLines);
+    // Au moins deux classes dans base pour qu'un move soit possible
+    if (baseClasses.size === 0 || branchClasses.size === 0)
+        return [];
+    const results = [];
+    for (const [sourceClass, baseMethods] of baseClasses) {
+        for (const method of baseMethods) {
+            if (results.length >= max)
+                break;
+            // La méthode doit avoir disparu de sa classe d'origine dans branch
+            const stillHere = branchClasses.get(sourceClass)?.has(method) ?? false;
+            if (stillHere)
+                continue;
+            // Chercher dans quelle autre classe elle est apparue
+            for (const [targetClass, targetMethods] of branchClasses) {
+                if (targetClass === sourceClass)
+                    continue;
+                if (targetMethods.has(method)) {
+                    results.push({
+                        kind: "move-method",
+                        oldName: method,
+                        sourceClass,
+                        targetClass,
+                    });
+                    break;
+                }
+            }
+        }
+    }
+    return results;
+}
+// ─── API publique ─────────────────────────────────────────────────────────────
+/**
+ * Détecte les refactorings entre la version de base d'un fichier et une branche.
+ *
+ * Point d'entrée principal du module. Appelé deux fois par l'orchestrateur
+ * RefMerge — une fois pour `(base, ours)`, une fois pour `(base, theirs)`.
+ *
+ * @param baseLines       Lignes du fichier dans la version de base (ancêtre commun)
+ * @param branchLines     Lignes du fichier dans la branche (ours ou theirs)
+ * @param maxRefactorings Quota maximum de refactorings retournés (défaut: 10)
+ * @returns               Liste des refactorings détectés, triée par type de confiance
+ *                        (rename-top-level > rename-local > move-method).
+ *                        Retourne `[]` en cas d'erreur ou si aucun refactoring détecté.
+ *
+ * @example
+ * ```ts
+ * const refs = detectRefactorings(
+ *   ["function foo(x) { return x + 1; }"],
+ *   ["function foo(value) { return value + 1; }"],
+ * );
+ * // refs = [{ kind: "rename-local", oldName: "x", newName: "value", scope: "foo" }]
+ * ```
+ */
+export function detectRefactorings(baseLines, branchLines, maxRefactorings = 10) {
+    try {
+        if (baseLines.length === 0 || branchLines.length === 0)
+            return [];
+        // Cas trivial : contenus identiques — aucun refactoring
+        if (arraysEqual(baseLines, branchLines))
+            return [];
+        const results = [];
+        // 1. Renames (rename-local + rename-top-level) — priorité haute
+        const renames = detectRenames(baseLines, branchLines, maxRefactorings);
+        results.push(...renames);
+        // 2. Move-method — uniquement si quota non épuisé
+        if (results.length < maxRefactorings) {
+            const moves = detectMoveMethod(baseLines, branchLines, maxRefactorings - results.length);
+            results.push(...moves);
+        }
+        return results;
+    }
+    catch {
+        // Dégradation silencieuse — jamais crasher l'orchestrateur
+        return [];
+    }
+}
+//# sourceMappingURL=detect.js.map

package/dist/refactoring/detect.js.map

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