@gitwand/core 2.5.1 → 2.8.0

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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"}

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"}