@gitwand/core 1.6.0

package/dist/resolver/format-dispatch.js

@@ -0,0 +1,51 @@
+/**
+ * Dispatch vers les résolveurs format-aware (Phase 7.3).
+ *
+ * Avant de passer au moteur textuel, on tente un résolveur spécialisé par
+ * format (JSON/JSONC, Markdown, YAML, Vue, CSS, Dockerfile, Dotenv, Cargo,
+ * imports…). Ces résolveurs effectuent une validation sémantique, ce qui
+ * justifie de bypasser le filtre de confiance textuel.
+ *
+ * Exception : le résolveur `imports` est sémantiquement équivalent à
+ * `non_overlapping` — il doit respecter la politique `allowNonOverlapping`
+ * ainsi que l'option globale `resolveNonOverlapping`.
+ *
+ * Ce module encapsule à la fois l'appel au dispatcher et la politique
+ * appliquée aux imports, et retourne un résultat tagué (`status`) que le
+ * moteur principal sait consommer.
+ */
+import { tryFormatAwareResolve } from "../resolvers/dispatcher.js";
+import { computeEffectivePolicy } from "./policy.js";
+/**
+ * Essaie les résolveurs format-aware pour ce hunk. Retourne le résultat
+ * tagué que le moteur principal sait router.
+ */
+export function dispatchFormatAware(hunk, filePath, options) {
+    const formatResult = tryFormatAwareResolve(hunk, filePath);
+    if (formatResult.resolverUsed === "none") {
+        return { status: "not-applicable", note: "" };
+    }
+    if (formatResult.lines === null) {
+        // Le résolveur spécialisé a échoué — pas de résolution, mais on garde
+        // le reason pour l'annoter dans le refus final du moteur textuel.
+        return { status: "not-applicable", note: formatResult.reason };
+    }
+    // Gate politique pour le résolveur d'imports (≈ non_overlapping)
+    if (formatResult.resolverUsed === "imports") {
+        if (!options.resolveNonOverlapping) {
+            return {
+                status: "rejected-policy",
+                reason: "Résolution d'imports (non-overlapping) désactivée par options (resolveNonOverlapping: false).",
+            };
+        }
+        const { policy, cfg } = computeEffectivePolicy(filePath, options);
+        if (!cfg.allowNonOverlapping) {
+            return {
+                status: "rejected-policy",
+                reason: `Résolution d'imports (non-overlapping) désactivée par la politique "${policy}".`,
+            };
+        }
+    }
+    return { status: "resolved", lines: formatResult.lines, reason: formatResult.reason };
+}
+//# sourceMappingURL=format-dispatch.js.map

package/dist/resolver/format-dispatch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"format-dispatch.js","sourceRoot":"","sources":["../../src/resolver/format-dispatch.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAGH,OAAO,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AACnE,OAAO,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAUrD;;;GAGG;AACH,MAAM,UAAU,mBAAmB,CACjC,IAAkB,EAClB,QAAgB,EAChB,OAAiC;IAEjC,MAAM,YAAY,GAAG,qBAAqB,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;IAC3D,IAAI,YAAY,CAAC,YAAY,KAAK,MAAM,EAAE,CAAC;QACzC,OAAO,EAAE,MAAM,EAAE,gBAAgB,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC;IAChD,CAAC;IAED,IAAI,YAAY,CAAC,KAAK,KAAK,IAAI,EAAE,CAAC;QAChC,sEAAsE;QACtE,kEAAkE;QAClE,OAAO,EAAE,MAAM,EAAE,gBAAgB,EAAE,IAAI,EAAE,YAAY,CAAC,MAAM,EAAE,CAAC;IACjE,CAAC;IAED,iEAAiE;IACjE,IAAI,YAAY,CAAC,YAAY,KAAK,SAAS,EAAE,CAAC;QAC5C,IAAI,CAAC,OAAO,CAAC,qBAAqB,EAAE,CAAC;YACnC,OAAO;gBACL,MAAM,EAAE,iBAAiB;gBACzB,MAAM,EAAE,+FAA+F;aACxG,CAAC;QACJ,CAAC;QACD,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,GAAG,sBAAsB,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;QAClE,IAAI,CAAC,GAAG,CAAC,mBAAmB,EAAE,CAAC;YAC7B,OAAO;gBACL,MAAM,EAAE,iBAAiB;gBACzB,MAAM,EAAE,uEAAuE,MAAM,IAAI;aAC1F,CAAC;QACJ,CAAC;IACH,CAAC;IAED,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,KAAK,EAAE,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,YAAY,CAAC,MAAM,EAAE,CAAC;AACxF,CAAC"}

package/dist/resolver/generated-detection.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Détection des fichiers auto-générés (lockfiles, bundles, manifests…).
+ *
+ * Ces fichiers ne doivent pas être mergés ligne par ligne : le moteur les
+ * reclassifie en `generated_file` et utilise `stripVolatileValues` pour
+ * comparer les deux côtés modulo les valeurs volatiles (hashes, URLs,
+ * timestamps). Extrait de `resolver.ts` lors du split P1.1.
+ */
+import type { ConflictHunk } from "../types.js";
+/** Patterns de fichiers auto-générés qui ne doivent pas être mergés ligne par ligne. */
+export declare const GENERATED_FILE_PATTERNS: Array<{
+    pattern: RegExp;
+    label: string;
+}>;
+/**
+ * Retourne `generated: true` si le chemin correspond à un pattern auto-généré.
+ *
+ * Les `userGlobs` optionnels (P2.4) permettent d'étendre les built-ins avec des
+ * patterns glob définis dans `.gitwandrc` (ex: `src/**\/*.generated.ts`, `*.pb.go`,
+ * `api/openapi-client/**`). Les built-ins sont checkés en premier (plus rapide,
+ * label descriptif) ; les user patterns ne sont évalués qu'en fallback.
+ *
+ * @param filePath - Chemin du fichier à tester
+ * @param userGlobs - Patterns glob supplémentaires issus de la config projet
+ */
+export declare function isGeneratedFile(filePath: string, userGlobs?: readonly string[]): {
+    generated: boolean;
+    label: string;
+};
+/**
+ * Supprime les valeurs volatiles (hashes, timestamps, resolved URLs, integrity)
+ * d'un bloc de lignes pour permettre une comparaison structurelle.
+ * Utilisé pour détecter les conflits cosmétiques dans les fichiers générés.
+ */
+export declare function stripVolatileValues(lines: string[]): string;
+/**
+ * Reclassifie un hunk `complex` en `generated_file` lorsque le chemin
+ * correspond à un pattern auto-généré. Retourne une copie du hunk avec
+ * le type, la confiance, l'explication et la trace mis à jour.
+ *
+ * Si le hunk n'est pas `complex` ou si le fichier n'est pas auto-généré,
+ * le hunk est retourné tel quel.
+ */
+export declare function reclassifyIfGenerated(hunk: ConflictHunk, genInfo: {
+    generated: boolean;
+    label: string;
+}): ConflictHunk;
+//# sourceMappingURL=generated-detection.d.ts.map

package/dist/resolver/generated-detection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generated-detection.d.ts","sourceRoot":"","sources":["../../src/resolver/generated-detection.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAiC,MAAM,aAAa,CAAC;AAG/E,wFAAwF;AACxF,eAAO,MAAM,uBAAuB,EAAE,KAAK,CAAC;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAY7E,CAAC;AAEF;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,MAAM,EAChB,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,GAC5B;IAAE,SAAS,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAcvC;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,CAkB3D;AAED;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,YAAY,EAClB,OAAO,EAAE;IAAE,SAAS,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAC7C,YAAY,CA4Cd"}

package/dist/resolver/generated-detection.js

@@ -0,0 +1,123 @@
+/**
+ * Détection des fichiers auto-générés (lockfiles, bundles, manifests…).
+ *
+ * Ces fichiers ne doivent pas être mergés ligne par ligne : le moteur les
+ * reclassifie en `generated_file` et utilise `stripVolatileValues` pour
+ * comparer les deux côtés modulo les valeurs volatiles (hashes, URLs,
+ * timestamps). Extrait de `resolver.ts` lors du split P1.1.
+ */
+import { matchGlob } from "../config.js";
+/** Patterns de fichiers auto-générés qui ne doivent pas être mergés ligne par ligne. */
+export const GENERATED_FILE_PATTERNS = [
+    { pattern: /package-lock\.json$/i, label: "npm lockfile" },
+    { pattern: /yarn\.lock$/i, label: "yarn lockfile" },
+    { pattern: /pnpm-lock\.yaml$/i, label: "pnpm lockfile" },
+    { pattern: /composer\.lock$/i, label: "composer lockfile" },
+    { pattern: /Gemfile\.lock$/i, label: "bundler lockfile" },
+    { pattern: /Cargo\.lock$/i, label: "cargo lockfile" },
+    { pattern: /\.min\.(js|css)$/i, label: "fichier minifié" },
+    { pattern: /\bdist\//, label: "fichier build dist/" },
+    { pattern: /\bbuild\/manifest\.json$/i, label: "manifest de build" },
+    { pattern: /\.bundle\.(js|css)$/i, label: "bundle" },
+    { pattern: /mix-manifest\.json$/i, label: "Laravel Mix manifest" },
+];
+/**
+ * Retourne `generated: true` si le chemin correspond à un pattern auto-généré.
+ *
+ * Les `userGlobs` optionnels (P2.4) permettent d'étendre les built-ins avec des
+ * patterns glob définis dans `.gitwandrc` (ex: `src/**\/*.generated.ts`, `*.pb.go`,
+ * `api/openapi-client/**`). Les built-ins sont checkés en premier (plus rapide,
+ * label descriptif) ; les user patterns ne sont évalués qu'en fallback.
+ *
+ * @param filePath - Chemin du fichier à tester
+ * @param userGlobs - Patterns glob supplémentaires issus de la config projet
+ */
+export function isGeneratedFile(filePath, userGlobs) {
+    for (const { pattern, label } of GENERATED_FILE_PATTERNS) {
+        if (pattern.test(filePath)) {
+            return { generated: true, label };
+        }
+    }
+    if (userGlobs) {
+        for (const glob of userGlobs) {
+            if (matchGlob(glob, filePath)) {
+                return { generated: true, label: `user pattern: ${glob}` };
+            }
+        }
+    }
+    return { generated: false, label: "" };
+}
+/**
+ * Supprime les valeurs volatiles (hashes, timestamps, resolved URLs, integrity)
+ * d'un bloc de lignes pour permettre une comparaison structurelle.
+ * Utilisé pour détecter les conflits cosmétiques dans les fichiers générés.
+ */
+export function stripVolatileValues(lines) {
+    return lines
+        .map((line) => line
+        // SHA/integrity hashes
+        .replace(/sha[0-9]+-[A-Za-z0-9+/=]+/g, "<hash>")
+        // npm resolved URLs with version+hash
+        .replace(/"resolved":\s*"[^"]+"/g, '"resolved": "<url>"')
+        // integrity fields
+        .replace(/"integrity":\s*"[^"]+"/g, '"integrity": "<hash>"')
+        // Generic hex hashes (7+ chars)
+        .replace(/\b[a-f0-9]{7,64}\b/g, "<hex>")
+        // ISO timestamps
+        .replace(/\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}(:\d{2})?(\.\d+)?(Z|[+-]\d{2}:?\d{2})?/g, "<ts>")
+        // Semver with build metadata
+        .replace(/\d+\.\d+\.\d+[-+][A-Za-z0-9.]+/g, "<ver>"))
+        .join("\n");
+}
+/**
+ * Reclassifie un hunk `complex` en `generated_file` lorsque le chemin
+ * correspond à un pattern auto-généré. Retourne une copie du hunk avec
+ * le type, la confiance, l'explication et la trace mis à jour.
+ *
+ * Si le hunk n'est pas `complex` ou si le fichier n'est pas auto-généré,
+ * le hunk est retourné tel quel.
+ */
+export function reclassifyIfGenerated(hunk, genInfo) {
+    if (!genInfo.generated || hunk.type !== "complex") {
+        return hunk;
+    }
+    const generatedScore = {
+        score: 72,
+        label: "high",
+        dimensions: {
+            typeClassification: 90,
+            dataRisk: 30,
+            scopeImpact: 15,
+            fileFrequency: 0,
+            baseAvailability: 0,
+        },
+        boosters: [`Chemin correspond au pattern de fichier auto-généré : ${genInfo.label}`],
+        penalties: ["Le contenu sera régénéré — theirs est supposé plus récent"],
+    };
+    return {
+        ...hunk,
+        type: "generated_file",
+        confidence: generatedScore,
+        explanation: `Fichier auto-généré (${genInfo.label}). Ce fichier sera régénéré après le merge. Résolution proposée : accepter theirs et relancer le build.`,
+        // Update the trace to reflect the reclassification
+        trace: {
+            ...hunk.trace,
+            selected: "generated_file",
+            summary: `Fichier auto-généré (${genInfo.label}) — reclassifié depuis complex.`,
+            steps: [
+                ...hunk.trace.steps.slice(0, -1), // remove the "complex passed: true" step
+                {
+                    type: "complex",
+                    passed: false,
+                    reason: `Reclassifié : fichier auto-généré (${genInfo.label}) détecté par son chemin.`,
+                },
+                {
+                    type: "generated_file",
+                    passed: true,
+                    reason: `Chemin correspond au pattern de fichier auto-généré : ${genInfo.label}.`,
+                },
+            ],
+        },
+    };
+}
+//# sourceMappingURL=generated-detection.js.map

package/dist/resolver/generated-detection.js.map

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

package/dist/resolver/index.d.ts

@@ -0,0 +1,26 @@
+/**
+ * GitWand Conflict Resolver — orchestration.
+ *
+ * Moteur de résolution automatique des conflits. Pour chaque hunk :
+ * 1. applique la pénalité « zone chaude » (v1.4) si nécessaire,
+ * 2. reclassifie les hunks complex en `generated_file` si le chemin matche,
+ * 3. tente un résolveur format-aware (JSON/MD/YAML/Vue/CSS/imports…),
+ * 4. à défaut, applique la politique de merge et le seuil de confiance,
+ * 5. invoque le moteur textuel (`assembleResolution`),
+ * 6. valide le contenu fusionné en sortie (marqueurs résiduels, JSON).
+ *
+ * Issu du split P1.1 de `resolver.ts`. Le fichier `packages/core/src/resolver.ts`
+ * reste en place comme shim de re-export pour les consommateurs qui importent
+ * `resolve` depuis `../resolver.js`.
+ */
+import type { GitWandOptions, MergeResult } from "../types.js";
+/**
+ * Analyse et résout automatiquement les conflits d'un fichier.
+ *
+ * @param conflictedContent - Le contenu du fichier avec marqueurs de conflit Git
+ * @param filePath - Le chemin du fichier (pour le reporting)
+ * @param userOptions - Options de configuration
+ * @returns Le résultat de la résolution avec traces et validation
+ */
+export declare function resolve(conflictedContent: string, filePath: string, userOptions?: GitWandOptions): MergeResult;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/resolver/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAGV,cAAc,EAEd,WAAW,EAGZ,MAAM,aAAa,CAAC;AAgErB;;;;;;;GAOG;AACH,wBAAgB,OAAO,CACrB,iBAAiB,EAAE,MAAM,EACzB,QAAQ,EAAE,MAAM,EAChB,WAAW,GAAE,cAAmB,GAC/B,WAAW,CAgGb"}

package/dist/resolver/index.js

@@ -0,0 +1,147 @@
+/**
+ * GitWand Conflict Resolver — orchestration.
+ *
+ * Moteur de résolution automatique des conflits. Pour chaque hunk :
+ * 1. applique la pénalité « zone chaude » (v1.4) si nécessaire,
+ * 2. reclassifie les hunks complex en `generated_file` si le chemin matche,
+ * 3. tente un résolveur format-aware (JSON/MD/YAML/Vue/CSS/imports…),
+ * 4. à défaut, applique la politique de merge et le seuil de confiance,
+ * 5. invoque le moteur textuel (`assembleResolution`),
+ * 6. valide le contenu fusionné en sortie (marqueurs résiduels, JSON).
+ *
+ * Issu du split P1.1 de `resolver.ts`. Le fichier `packages/core/src/resolver.ts`
+ * reste en place comme shim de re-export pour les consommateurs qui importent
+ * `resolve` depuis `../resolver.js`.
+ */
+import { parseConflictMarkers, toConflictHunk } from "../parser.js";
+import { EMPTY_VALIDATION, validateMergedContent } from "./validation.js";
+import { isGeneratedFile, reclassifyIfGenerated } from "./generated-detection.js";
+import { CONFIDENCE_ORDER, DEFAULT_OPTIONS, applyFileFrequencyPenalty, computeEffectiveMinConfidence, computeEffectivePolicy, } from "./policy.js";
+import { dispatchFormatAware } from "./format-dispatch.js";
+import { assembleResolution } from "./assemble.js";
+/**
+ * Résout automatiquement un hunk de conflit.
+ *
+ * @param hunk - Le hunk à résoudre
+ * @param filePath - Chemin du fichier (pour le dispatch format-aware et la politique)
+ * @param options - Options de configuration (complètes, déjà fusionnées avec les défauts)
+ * @returns Les lignes résolues + la raison, ou `null` + raison de refus
+ */
+function resolveHunk(hunk, filePath, options) {
+    // explainOnly : ne pas appliquer de résolution, juste tracer
+    if (options.explainOnly) {
+        return {
+            lines: null,
+            reason: `Mode explain-only : résolution non appliquée (type: ${hunk.type}, confiance: ${hunk.confidence.label} [score: ${hunk.confidence.score}]).`,
+        };
+    }
+    // Phase 7.3 — Dispatch format-aware (bypasse le seuil de confiance textuel
+    // car les résolveurs spécialisés font une validation sémantique).
+    const dispatch = dispatchFormatAware(hunk, filePath, options);
+    if (dispatch.status === "resolved") {
+        return { lines: dispatch.lines, reason: dispatch.reason };
+    }
+    if (dispatch.status === "rejected-policy") {
+        return { lines: null, reason: dispatch.reason };
+    }
+    // dispatch.status === "not-applicable" → on continue vers le moteur textuel.
+    // `dispatch.note` porte la raison d'échec du résolveur spécialisé (pour
+    // annotation du refus final si le seuil de confiance bloque aussi).
+    // Phase 7.4 — Politique de merge effective pour ce fichier
+    const { policy: effectivePolicy, cfg: policyCfg } = computeEffectivePolicy(filePath, options);
+    const effectiveMinConfidence = computeEffectiveMinConfidence(policyCfg, options);
+    // Vérifier le niveau de confiance minimum
+    if (CONFIDENCE_ORDER[hunk.confidence.label] < CONFIDENCE_ORDER[effectiveMinConfidence]) {
+        return {
+            lines: null,
+            reason: `Confiance ${hunk.confidence.label} (score: ${hunk.confidence.score}) insuffisante (minimum requis : ${effectiveMinConfidence}, politique : ${effectivePolicy}).${dispatch.note ? ` [${dispatch.note}]` : ""}`,
+        };
+    }
+    return assembleResolution(hunk, options, effectivePolicy, policyCfg);
+}
+/**
+ * Analyse et résout automatiquement les conflits d'un fichier.
+ *
+ * @param conflictedContent - Le contenu du fichier avec marqueurs de conflit Git
+ * @param filePath - Le chemin du fichier (pour le reporting)
+ * @param userOptions - Options de configuration
+ * @returns Le résultat de la résolution avec traces et validation
+ */
+export function resolve(conflictedContent, filePath, userOptions = {}) {
+    const options = { ...DEFAULT_OPTIONS, ...userOptions };
+    const { segments } = parseConflictMarkers(conflictedContent);
+    const hunks = [];
+    const resolutions = [];
+    const outputLines = [];
+    let allResolved = true;
+    // Détecter si le fichier est auto-généré (built-ins + user patterns P2.4)
+    const genInfo = isGeneratedFile(filePath, options.generatedFiles);
+    // v1.4 — fileFrequency : compteur de hunks "complex" déjà vus dans ce fichier.
+    // Appliqué comme pénalité sur la dimension fileFrequency du score de confiance.
+    let priorComplexHunks = 0;
+    for (const segment of segments) {
+        if (segment.type === "text") {
+            outputLines.push(...segment.lines);
+            continue;
+        }
+        let hunk = toConflictHunk(segment.conflict);
+        // v1.4 — Appliquer la pénalité fileFrequency si des hunks complexes ont déjà été vus
+        hunk = applyFileFrequencyPenalty(hunk, priorComplexHunks);
+        // Si fichier auto-généré et hunk classifié "complex", reclassifier en "generated_file"
+        hunk = reclassifyIfGenerated(hunk, genInfo);
+        hunks.push(hunk);
+        const { lines: resolvedLines, reason: resolutionReason } = resolveHunk(hunk, filePath, options);
+        const autoResolved = resolvedLines !== null;
+        // v1.4 — Incrémenter le compteur de hunks complexes non résolus pour fileFrequency
+        if (!autoResolved && hunk.type === "complex") {
+            priorComplexHunks++;
+        }
+        resolutions.push({ hunk, resolvedLines, autoResolved, resolutionReason });
+        if (autoResolved) {
+            outputLines.push(...resolvedLines);
+            if (options.verbose) {
+                console.log(`  [GitWand] Auto-resolved (${hunk.type}): L${hunk.startLine} — ${hunk.explanation}`);
+                console.log(`    Trace: ${hunk.trace.summary}`);
+            }
+        }
+        else {
+            // Remettre les marqueurs de conflit pour les conflits non résolus
+            outputLines.push(`<<<<<<< ours`);
+            outputLines.push(...hunk.oursLines);
+            if (hunk.baseLines.length > 0) {
+                outputLines.push(`||||||| base`);
+                outputLines.push(...hunk.baseLines);
+            }
+            outputLines.push(`=======`);
+            outputLines.push(...hunk.theirsLines);
+            outputLines.push(`>>>>>>> theirs`);
+            allResolved = false;
+        }
+    }
+    // Calculer les stats
+    const byType = {};
+    for (const hunk of hunks) {
+        byType[hunk.type] = (byType[hunk.type] || 0) + 1;
+    }
+    const autoResolvedCount = resolutions.filter((r) => r.autoResolved).length;
+    const stats = {
+        totalConflicts: hunks.length,
+        autoResolved: autoResolvedCount,
+        remaining: hunks.length - autoResolvedCount,
+        byType,
+    };
+    const mergedContent = allResolved ? outputLines.join("\n") : null;
+    // Phase 7.2 — Validation post-merge
+    const validation = mergedContent !== null
+        ? validateMergedContent(mergedContent, filePath)
+        : EMPTY_VALIDATION;
+    return {
+        filePath,
+        mergedContent,
+        hunks,
+        resolutions,
+        stats,
+        validation,
+    };
+}
+//# sourceMappingURL=index.js.map

package/dist/resolver/index.js.map

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

package/dist/resolver/policy.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Politique de merge effective + helpers de scoring.
+ *
+ * Regroupe :
+ * - `DEFAULT_OPTIONS` — valeurs par défaut des `GitWandOptions`
+ * - `CONFIDENCE_ORDER` — ordre total sur les labels de confiance
+ * - `computeEffectivePolicy` — résout la politique applicable à un fichier
+ *   (glob overrides > politique globale) et sa `PolicyConfig` dérivée
+ * - `computeEffectiveMinConfidence` — seuil de confiance effectif (min entre
+ *   option globale et politique, donc le plus permissif des deux)
+ * - `applyFileFrequencyPenalty` — v1.4 « zone chaude » : pénalise la confiance
+ *   d'un hunk si le même fichier contient déjà des hunks complexes non résolus
+ *
+ * Extrait de `resolver.ts` lors du split P1.1.
+ */
+import type { ConflictHunk, Confidence, GitWandOptions } from "../types.js";
+import { type MergePolicy, type PolicyConfig } from "../config.js";
+/** Options par défaut. */
+export declare const DEFAULT_OPTIONS: Required<GitWandOptions>;
+/** Ordre de confiance pour comparaison. */
+export declare const CONFIDENCE_ORDER: Record<Confidence, number>;
+/**
+ * Résout la politique effective pour un fichier donné.
+ *
+ * La priorité est : pattern-override le plus spécifique → politique globale.
+ * Retourne à la fois la politique et sa `PolicyConfig` dérivée, afin de ne
+ * pas recalculer la conversion chez les appelants.
+ */
+export declare function computeEffectivePolicy(filePath: string, options: Required<GitWandOptions>): {
+    policy: MergePolicy;
+    cfg: PolicyConfig;
+};
+/**
+ * Calcule le seuil de confiance effectif : le `min` entre la politique et
+ * l'option globale. Motivation : la politique peut abaisser le seuil, et
+ * une option explicite peut aussi l'abaisser en dessous du défaut de la
+ * politique — on prend donc toujours le plus permissif.
+ */
+export declare function computeEffectiveMinConfidence(policyCfg: PolicyConfig, options: Required<GitWandOptions>): Confidence;
+/**
+ * v1.4 — Applique la pénalité « zone chaude » sur la confiance d'un hunk si
+ * `priorComplexHunks > 0` hunks complexes non résolus ont déjà été vus dans
+ * le même fichier. Ne s'applique pas aux hunks `complex` eux-mêmes.
+ *
+ * La formule recalcule `score` à partir des dimensions, avec :
+ *   `fileFrequency = min(100, priorComplexHunks × 20)`
+ *   `score = typeClassification − 0.40·dataRisk − 0.15·scopeImpact
+ *            − 0.10·fileFrequency + 0.05·baseAvailability`
+ *
+ * Les labels sont re-dérivés via les seuils : 92 / 68 / 44.
+ */
+export declare function applyFileFrequencyPenalty(hunk: ConflictHunk, priorComplexHunks: number): ConflictHunk;
+//# sourceMappingURL=policy.d.ts.map

package/dist/resolver/policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"policy.d.ts","sourceRoot":"","sources":["../../src/resolver/policy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAC5E,OAAO,EAIL,KAAK,WAAW,EAChB,KAAK,YAAY,EAClB,MAAM,cAAc,CAAC;AAEtB,0BAA0B;AAC1B,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,cAAc,CASpD,CAAC;AAEF,2CAA2C;AAC3C,eAAO,MAAM,gBAAgB,EAAE,MAAM,CAAC,UAAU,EAAE,MAAM,CAKvD,CAAC;AAEF;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,QAAQ,CAAC,cAAc,CAAC,GAChC;IAAE,MAAM,EAAE,WAAW,CAAC;IAAC,GAAG,EAAE,YAAY,CAAA;CAAE,CAO5C;AAED;;;;;GAKG;AACH,wBAAgB,6BAA6B,CAC3C,SAAS,EAAE,YAAY,EACvB,OAAO,EAAE,QAAQ,CAAC,cAAc,CAAC,GAChC,UAAU,CAIZ;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,YAAY,EAClB,iBAAiB,EAAE,MAAM,GACxB,YAAY,CAiCd"}

package/dist/resolver/policy.js

@@ -0,0 +1,99 @@
+/**
+ * Politique de merge effective + helpers de scoring.
+ *
+ * Regroupe :
+ * - `DEFAULT_OPTIONS` — valeurs par défaut des `GitWandOptions`
+ * - `CONFIDENCE_ORDER` — ordre total sur les labels de confiance
+ * - `computeEffectivePolicy` — résout la politique applicable à un fichier
+ *   (glob overrides > politique globale) et sa `PolicyConfig` dérivée
+ * - `computeEffectiveMinConfidence` — seuil de confiance effectif (min entre
+ *   option globale et politique, donc le plus permissif des deux)
+ * - `applyFileFrequencyPenalty` — v1.4 « zone chaude » : pénalise la confiance
+ *   d'un hunk si le même fichier contient déjà des hunks complexes non résolus
+ *
+ * Extrait de `resolver.ts` lors du split P1.1.
+ */
+import { DEFAULT_POLICY, effectivePolicyForFile, policyToConfig, } from "../config.js";
+/** Options par défaut. */
+export const DEFAULT_OPTIONS = {
+    resolveWhitespace: true,
+    resolveNonOverlapping: true,
+    minConfidence: "high",
+    verbose: false,
+    explainOnly: false,
+    policy: DEFAULT_POLICY,
+    patternOverrides: {},
+    generatedFiles: [],
+};
+/** Ordre de confiance pour comparaison. */
+export const CONFIDENCE_ORDER = {
+    certain: 4,
+    high: 3,
+    medium: 2,
+    low: 1,
+};
+/**
+ * Résout la politique effective pour un fichier donné.
+ *
+ * La priorité est : pattern-override le plus spécifique → politique globale.
+ * Retourne à la fois la politique et sa `PolicyConfig` dérivée, afin de ne
+ * pas recalculer la conversion chez les appelants.
+ */
+export function computeEffectivePolicy(filePath, options) {
+    const policy = effectivePolicyForFile(filePath, options.policy, options.patternOverrides);
+    return { policy, cfg: policyToConfig(policy) };
+}
+/**
+ * Calcule le seuil de confiance effectif : le `min` entre la politique et
+ * l'option globale. Motivation : la politique peut abaisser le seuil, et
+ * une option explicite peut aussi l'abaisser en dessous du défaut de la
+ * politique — on prend donc toujours le plus permissif.
+ */
+export function computeEffectiveMinConfidence(policyCfg, options) {
+    return CONFIDENCE_ORDER[policyCfg.minConfidence] < CONFIDENCE_ORDER[options.minConfidence]
+        ? policyCfg.minConfidence
+        : options.minConfidence;
+}
+/**
+ * v1.4 — Applique la pénalité « zone chaude » sur la confiance d'un hunk si
+ * `priorComplexHunks > 0` hunks complexes non résolus ont déjà été vus dans
+ * le même fichier. Ne s'applique pas aux hunks `complex` eux-mêmes.
+ *
+ * La formule recalcule `score` à partir des dimensions, avec :
+ *   `fileFrequency = min(100, priorComplexHunks × 20)`
+ *   `score = typeClassification − 0.40·dataRisk − 0.15·scopeImpact
+ *            − 0.10·fileFrequency + 0.05·baseAvailability`
+ *
+ * Les labels sont re-dérivés via les seuils : 92 / 68 / 44.
+ */
+export function applyFileFrequencyPenalty(hunk, priorComplexHunks) {
+    if (priorComplexHunks <= 0 || hunk.type === "complex") {
+        return hunk;
+    }
+    const ff = Math.min(100, priorComplexHunks * 20);
+    const d = hunk.confidence.dimensions;
+    const raw = d.typeClassification
+        - d.dataRisk * 0.40
+        - d.scopeImpact * 0.15
+        - ff * 0.10
+        + (d.baseAvailability ?? 0) * 0.05;
+    const newScore = Math.round(Math.max(0, Math.min(100, raw)));
+    const newLabel = newScore >= 92 ? "certain"
+        : newScore >= 68 ? "high"
+            : newScore >= 44 ? "medium"
+                : "low";
+    return {
+        ...hunk,
+        confidence: {
+            ...hunk.confidence,
+            score: newScore,
+            label: newLabel,
+            dimensions: { ...d, fileFrequency: ff },
+            penalties: [
+                ...hunk.confidence.penalties,
+                `Zone chaude — ${priorComplexHunks} hunk${priorComplexHunks > 1 ? "s" : ""} complexe${priorComplexHunks > 1 ? "s" : ""} déjà vus dans ce fichier (−${(ff * 0.10).toFixed(1)} pts)`,
+            ],
+        },
+    };
+}
+//# sourceMappingURL=policy.js.map

package/dist/resolver/policy.js.map

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

package/dist/resolver/validation.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Post-merge validation (Phase 7.2).
+ *
+ * Vérifie que le contenu fusionné ne laisse pas de marqueurs de conflit
+ * résiduels et, pour les formats structurés (JSON/JSONC, YAML, TOML),
+ * qu'il reste syntaxiquement valide. Extrait de `resolver.ts` lors du
+ * split P1.1, puis étendu YAML/TOML en P2.5.
+ */
+import type { ValidationResult } from "../types.js";
+/** Patterns de marqueurs de conflit résiduels. */
+export declare const RESIDUAL_MARKER_PATTERNS: RegExp[];
+/**
+ * Valide le contenu fusionné pour détecter les problèmes résiduels.
+ *
+ * Vérifie :
+ * 1. Marqueurs de conflit résiduels (indique une résolution incomplète)
+ * 2. Erreurs de syntaxe pour les formats structurés :
+ *    - JSON/JSONC (`.json`, `.jsonc`)
+ *    - YAML       (`.yaml`, `.yml`)
+ *    - TOML       (`.toml`)
+ *
+ * @param content - Contenu fusionné à valider
+ * @param filePath - Chemin du fichier (pour détecter le type)
+ */
+export declare function validateMergedContent(content: string, filePath: string): ValidationResult;
+/** Validation vide (pour les cas où le contenu n'est pas encore fusionné). */
+export declare const EMPTY_VALIDATION: ValidationResult;
+//# sourceMappingURL=validation.d.ts.map

package/dist/resolver/validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../src/resolver/validation.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAEpD,kDAAkD;AAClD,eAAO,MAAM,wBAAwB,UAKpC,CAAC;AA8CF;;;;;;;;;;;;GAYG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,gBAAgB,CAqBzF;AAED,8EAA8E;AAC9E,eAAO,MAAM,gBAAgB,EAAE,gBAK9B,CAAC"}