agentic-api 1.0.5 → 2.0.26

package/dist/src/rules/git/git.e2e.helper.d.ts

@@ -0,0 +1,104 @@
+import { SimpleGit } from 'simple-git';
+import { RulesGitConfig, GitCommitHistory, RuleUser, PRInfo, PRMergeResult, RulePullRequestDetails } from '../types';
+import { IE2ETestOperations, E2ETestConfig, E2ETestResult, IRulesE2EAssertions } from './git.helper';
+import { IConcurrencyManager, IGitNotesOperations } from '../types.helpers';
+/**
+ * Helper E2E pour les tests d'intégration avec un vrai repository Git
+ * Implémente toutes les interfaces pour permettre des tests complets
+ */
+export declare class GitE2EHelper implements IE2ETestOperations, IRulesE2EAssertions {
+    readonly git: SimpleGit;
+    readonly config: RulesGitConfig;
+    readonly concurrency: IConcurrencyManager;
+    readonly notes: IGitNotesOperations;
+    private tempRepoPath;
+    private isInitialized;
+    constructor(config: E2ETestConfig);
+    initTemporaryRepo(): Promise<void>;
+    cleanup(): Promise<void>;
+    getFileContent(filePath: string, branch?: string): Promise<GitCommitHistory | null>;
+    listFilesInBranch(branch: string, pattern?: string): Promise<string[]>;
+    fileExistsInBranch(filePath: string, branch: string): Promise<boolean>;
+    isFileMerged(filePath: string, from: string, target?: string): Promise<boolean>;
+    getAllBranches(options?: {
+        unmergedOnly?: boolean;
+    }): Promise<string[]>;
+    validateConfiguration(): Promise<any>;
+    isPRClosed(branch: string): Promise<boolean>;
+    isPRClosedRobust(branch: string, config?: RulesGitConfig): Promise<boolean>;
+    closePR(branch: string, author: RuleUser, message?: string): Promise<PRMergeResult>;
+    closePRRobust(branch: string, closedBy: RuleUser, message: string, config?: RulesGitConfig): Promise<PRMergeResult>;
+    getAllPR(options?: {
+        closed?: boolean;
+        validationPrefix?: string;
+    }): Promise<PRInfo[]>;
+    getNextPRNumber(validationPrefix: string): Promise<number>;
+    newPR(files: string[], description: string, author: RuleUser, options?: {
+        content?: string[];
+        editorBranch?: string;
+        validationPrefix?: string;
+        rulesGitConfig?: RulesGitConfig;
+    }): Promise<PRInfo>;
+    getPRInfo(branch: string, config?: RulesGitConfig): Promise<PRInfo>;
+    updatePRComments(branch: string, details: RulePullRequestDetails): Promise<PRInfo>;
+    syncPR(branch: string, user: RuleUser): Promise<void>;
+    /**
+     * Crée un fichier dans le repository
+     * @param filePath Chemin du fichier
+     * @param content Contenu du fichier
+     * @param branch Branche optionnelle (par défaut: draft)
+     */
+    createOrEditFile(filePath: string, content: string, branch?: string, config?: RulesGitConfig): Promise<GitCommitHistory>;
+    /**
+     * Modifie un fichier existant
+     * @param filePath Chemin du fichier
+     * @param content Contenu du fichier
+     * @param branch Branche optionnelle (par défaut: draft)
+     */
+    editFile(filePath: string, content: string, branch?: string): Promise<GitCommitHistory>;
+    validateRepositoryState(): Promise<{
+        isValid: boolean;
+        branches: string[];
+        files: Record<string, string[]>;
+        errors: string[];
+    }>;
+    runCompleteWorkflow(files: {
+        path: string;
+        content: string;
+    }[], description: string): Promise<{
+        prBranch: string;
+        commitHash: string;
+        mergeCommitHash?: string;
+    }>;
+    assertFileContent(filePath: string, expectedContent: string, branch?: string): Promise<void>;
+    assertPRState(branch: string, expectedState: 'open' | 'closed'): Promise<void>;
+    assertFilemerged(filePath: string, fromBranch: string, toBranch?: string): Promise<void>;
+    assertBranchStructure(expectedBranches: string[]): Promise<void>;
+    assertGitHistory(expectedCommits: {
+        message: string;
+        author?: string;
+    }[]): Promise<void>;
+    /**
+     * Retourne le chemin du repository temporaire
+     */
+    getRepositoryPath(): string;
+}
+/**
+ * Factory pour créer des helpers E2E facilement
+ */
+export declare class GitE2EFactory {
+    static getDefaultHelper(): GitE2EHelper;
+    /**
+     * Crée un helper E2E avec un repository temporaire
+     */
+    static createE2EHelper(options?: {
+        autoCleanup?: boolean;
+        customConfig?: Partial<RulesGitConfig>;
+    }): Promise<GitE2EHelper>;
+    /**
+     * Crée un helper E2E et exécute un test complet
+     */
+    static runE2ETest(testName: string, testFunction: (helper: GitE2EHelper) => Promise<void>, options?: {
+        autoCleanup?: boolean;
+    }): Promise<E2ETestResult>;
+}

package/dist/src/rules/git/git.e2e.helper.js

@@ -0,0 +1,488 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitE2EFactory = exports.GitE2EHelper = void 0;
+const simple_git_1 = __importDefault(require("simple-git"));
+const fs_1 = require("fs");
+const path_1 = require("path");
+const os_1 = require("os");
+const index_1 = require("./index");
+/**
+ * Helper E2E pour les tests d'intégration avec un vrai repository Git
+ * Implémente toutes les interfaces pour permettre des tests complets
+ */
+class GitE2EHelper {
+    constructor(config) {
+        this.isInitialized = false;
+        this.tempRepoPath = config.tempDir;
+        this.config = config.gitConfig;
+        this.config.instance = this.git = (0, simple_git_1.default)({ baseDir: this.tempRepoPath, binary: 'git' });
+        delete this.config.reset;
+        // Concurrency manager réel (pas de mock)
+        this.concurrency = {
+            async withRetry(operation, options, operationName = 'unknown') {
+                let attempts = 0;
+                let lastError;
+                while (attempts < options.maxRetries) {
+                    attempts++;
+                    try {
+                        const result = await Promise.race([
+                            operation(),
+                            new Promise((_, reject) => setTimeout(() => reject(new Error('Operation timeout')), options.timeoutMs))
+                        ]);
+                        return { success: true, result, attempts };
+                    }
+                    catch (error) {
+                        lastError = error instanceof Error ? error : new Error(String(error));
+                        if (attempts < options.maxRetries) {
+                            const delay = options.retryDelayMs * Math.pow(2, attempts - 1) + Math.random() * 50;
+                            await new Promise(resolve => setTimeout(resolve, delay));
+                        }
+                    }
+                }
+                return {
+                    success: false,
+                    attempts,
+                    error: lastError
+                };
+            }
+        };
+        // Capture reference to git instance for closures
+        const gitInstance = this.git;
+        // Git Notes operations réelles
+        this.notes = {
+            async readNote(branch, namespace) {
+                return (0, index_1.gitReadNote)(gitInstance, branch, namespace);
+            },
+            async writeNote(branch, metadata, namespace) {
+                return (0, index_1.gitWriteNote)(gitInstance, branch, metadata, namespace);
+            },
+            async deleteNote(branch, author, namespace) {
+                console.log(`[DEBUG][E2EHelper.notes.deleteNote] Deleting note for ${branch} by ${author.name}`);
+                try {
+                    await gitInstance.raw(['notes', '--ref', namespace, 'remove', branch]);
+                }
+                catch {
+                    // Ignorer si la note n'existe pas
+                }
+            },
+        };
+    }
+    async initTemporaryRepo() {
+        if (this.isInitialized) {
+            return;
+        }
+        try {
+            // Créer le répertoire temporaire
+            await fs_1.promises.mkdir(this.tempRepoPath, { recursive: true });
+            // Create upload directory 
+            const uploadDir = this.config.uploadPath;
+            await fs_1.promises.mkdir(uploadDir, { recursive: true });
+            // Initialiser le repository Git
+            await this.git.init();
+            // Configuration Git de base
+            await this.git.addConfig('user.name', 'E2E Test');
+            await this.git.addConfig('user.email', 'e2e@test.com');
+            await this.git.addConfig('init.defaultBranch', this.config.mainBranch);
+            // Créer la branche main directement
+            await this.git.checkout(['-b', this.config.mainBranch]);
+            // Créer un commit initial
+            const readmePath = (0, path_1.join)(this.tempRepoPath, 'README.md');
+            await fs_1.promises.writeFile(readmePath, '# E2E Test Repository\n\nTemporary repository for E2E testing.');
+            await this.git.add('README.md');
+            await this.git.commit('Initial commit');
+            // Créer la branche draft à partir de main
+            await this.git.checkoutBranch(this.config.draftBranch, this.config.mainBranch);
+            // force reload of git config
+            this.config.reset = true;
+            await (0, index_1.gitLoad)(this.config);
+            // console.log(`🌶️ Helper.initTemporaryRepo: gitConfig: `,this.config.repoPath, 'reset:',this.config.reset);
+            delete this.config.reset;
+            this.isInitialized = true;
+        }
+        catch (error) {
+            throw new Error(`Échec de l'initialisation du repository E2E: ${error}`);
+        }
+    }
+    async cleanup() {
+        if (this.tempRepoPath) {
+            try {
+                await fs_1.promises.rm(this.tempRepoPath, { recursive: true, force: true });
+            }
+            catch (error) {
+                console.warn(`Erreur lors du nettoyage du repository E2E: ${error}`);
+            }
+        }
+    }
+    // ===== DÉLÉGATION VERS LES FONCTIONS REPO.TS =====
+    async getFileContent(filePath, branch) {
+        return (0, index_1.gitGetFileContent)(this.git, filePath, branch);
+    }
+    async listFilesInBranch(branch, pattern) {
+        // return gitGetDiffFiles(this.git, branch, this.config.draftBranch, pattern);
+        return (0, index_1.gitListFilesInBranch)(this.git, branch, pattern || '.md');
+    }
+    async fileExistsInBranch(filePath, branch) {
+        return (0, index_1.gitFileExistsInBranch)(this.git, filePath, branch);
+    }
+    async isFileMerged(filePath, from, target) {
+        return (0, index_1.gitIsFileMerged)(this.git, filePath, from, target);
+    }
+    async getAllBranches(options) {
+        return (0, index_1.gitGetAllBranches)(this.git, options);
+    }
+    async validateConfiguration() {
+        return (0, index_1.gitCheckConfiguration)(this.git);
+    }
+    async isPRClosed(branch) {
+        return (0, index_1.gitIsPRClosed)(this.git, branch);
+    }
+    async isPRClosedRobust(branch, config) {
+        return (0, index_1.gitIsPRClosedRobust)(this.git, branch, config || this.config);
+    }
+    async closePR(branch, author, message) {
+        console.log(`[DEBUG][E2EHelper.closePR] Closing PR: ${branch} by ${author.name}`);
+        return (0, index_1.gitClosePR)(this.git, branch, author, message);
+    }
+    async closePRRobust(branch, closedBy, message, config) {
+        return (0, index_1.gitClosePRRobust)(this.git, branch, closedBy, message, config || this.config);
+    }
+    async getAllPR(options) {
+        // Underlying gitGetAllPR uses global gitLoad(), so passing specific config here has no effect yet.
+        // Keeping rulesGitConfig in signature for potential future refactor of gitGetAllPR.
+        return (0, index_1.gitGetAllPR)(this.git, options);
+    }
+    async getNextPRNumber(validationPrefix) {
+        return (0, index_1.gitGetNextPRNumber)(this.git, validationPrefix);
+    }
+    async newPR(files, description, author, options) {
+        //console.log(`[DEBUG][E2EHelper.newPR] Creating new PR by ${author.name} for files: ${files.join(', ')}`);
+        const passOptions = { ...options, rulesGitConfig: options?.rulesGitConfig || this.config };
+        return (0, index_1.gitNewValidationRequest)(this.git, files, description, author, passOptions);
+    }
+    async getPRInfo(branch, config) {
+        const effectiveConfig = config || this.config;
+        // First, determine if the PR is closed using the robust method and effectiveConfig
+        // Then, load the PR info, passing the determined closed status
+        const prInfo = await (0, index_1.gitLoadPR)(this.git, branch);
+        if (!prInfo) {
+            throw new Error(`PR info not found for branch ${branch}`); // Should not happen if branch exists
+        }
+        prInfo.open = prInfo.metadata.status == 'open';
+        return prInfo;
+    }
+    async updatePRComments(branch, details) {
+        return (0, index_1.gitPRUpdateComments)(this.git, branch, details, this.config);
+    }
+    // FIXME: Cette fonction a un problème de gestion des métadonnées manquantes. Voir gitSyncPR pour les détails.
+    async syncPR(branch, user) {
+        return (0, index_1.gitSyncPR)(this.git, branch, user);
+    }
+    // ===== MÉTHODES E2E SPÉCIFIQUES =====
+    /**
+     * Crée un fichier dans le repository
+     * @param filePath Chemin du fichier
+     * @param content Contenu du fichier
+     * @param branch Branche optionnelle (par défaut: draft)
+     */
+    async createOrEditFile(filePath, content, branch, config) {
+        const user = { name: 'E2E Test', email: 'e2e@test.com' };
+        const targetBranch = branch || config?.draftBranch || this.config.draftBranch;
+        return (0, index_1.gitCreateOrEditFile)(this.git, filePath, targetBranch, content, user, config || this.config);
+    }
+    /**
+     * Modifie un fichier existant
+     * @param filePath Chemin du fichier
+     * @param content Contenu du fichier
+     * @param branch Branche optionnelle (par défaut: draft)
+     */
+    async editFile(filePath, content, branch) {
+        const user = { name: 'E2E Test', email: 'e2e@test.com' };
+        const targetBranch = branch || this.config.draftBranch;
+        return (0, index_1.gitEditFile)(this.git, filePath, targetBranch, content, user, this.config);
+    }
+    async validateRepositoryState() {
+        const errors = [];
+        let isValid = true;
+        try {
+            // Vérifier que c'est un repository Git valide
+            const isRepo = await this.git.checkIsRepo();
+            if (!isRepo) {
+                errors.push('Le répertoire n\'est pas un repository Git valide');
+                isValid = false;
+            }
+            // Lister les branches
+            const branches = await this.getAllBranches();
+            // Vérifier les branches obligatoires
+            if (!branches.includes(this.config.mainBranch)) {
+                errors.push(`Branche principale manquante: ${this.config.mainBranch}`);
+                isValid = false;
+            }
+            if (!branches.includes(this.config.draftBranch)) {
+                errors.push(`Branche draft manquante: ${this.config.draftBranch}`);
+                isValid = false;
+            }
+            // Lister les fichiers par branche
+            const files = {};
+            for (const branch of branches) {
+                try {
+                    files[branch] = await this.listFilesInBranch(branch);
+                }
+                catch (error) {
+                    errors.push(`Erreur lors de la lecture de la branche ${branch}: ${error}`);
+                    isValid = false;
+                }
+            }
+            return { isValid, branches, files, errors };
+        }
+        catch (error) {
+            errors.push(`Erreur lors de la validation: ${error}`);
+            return { isValid: false, branches: [], files: {}, errors };
+        }
+    }
+    async runCompleteWorkflow(files, description) {
+        const user = { name: 'E2E Workflow User', email: 'e2e.workflow@example.com' };
+        const filePaths = files.map(f => f.path);
+        const contents = files.map(f => f.content);
+        // 1. Create a new PR (contribution branch) with the initial content
+        const pr = await this.newPR(filePaths, description, user, {
+            content: contents,
+        });
+        const prBranch = pr.branch;
+        // Capture the initial commit hash on the PR branch
+        // newPR makes a commit, so we get its hash.
+        // If newPR makes multiple commits for multiple files, this gets the latest one.
+        let commitHash = '';
+        try {
+            await this.git.checkout(prBranch); // Ensure we are on the prBranch
+            const log = await this.git.log({ maxCount: 1 });
+            commitHash = log.latest?.hash || 'unknown-initial-commit-hash';
+            await this.git.checkout(this.config.draftBranch); // Go back to draftBranch or main for safety before next ops
+        }
+        catch (e) {
+            console.warn(`[E2EHelper.runCompleteWorkflow] Could not get initial commit hash for ${prBranch}: ${e}`);
+            commitHash = 'error-getting-initial-commit-hash';
+        }
+        // Verify files are on the PR branch
+        for (const file of files) {
+            await this.assertFileContent(file.path, file.content, prBranch);
+        }
+        // Verify files are NOT YET on rule-editor
+        for (const file of files) {
+            const existsOnRuleEditor = await this.fileExistsInBranch(file.path, this.config.draftBranch);
+            expect(existsOnRuleEditor).toBe(false);
+        }
+        // 2. Close the PR (merge the contribution branch into rule-editor)
+        /* const closureHash = */ await this.closePRRobust(// We don't need to store closureHash anymore
+        prBranch, user, `Validation E2E terminée for: ${description}`, this.config);
+        // 3. Verify files are now on rule-editor with correct content
+        await this.git.checkout(this.config.draftBranch);
+        for (const file of files) {
+            await this.assertFileContent(file.path, file.content, this.config.draftBranch);
+        }
+        // 4. Verify the contribution branch was merged into rule-editor (content check serves as primary)
+        // Get the hash of the merge commit on rule-editor
+        let mergeCommitHash;
+        try {
+            // Ensure we are on draftBranch to get its latest log
+            await this.git.checkout(this.config.draftBranch);
+            const log = await this.git.log({ maxCount: 1 }); // Get the latest commit on rule-editor
+            mergeCommitHash = log.latest?.hash;
+        }
+        catch (e) {
+            console.warn(`[E2EHelper.runCompleteWorkflow] Could not get merge commit hash on ${this.config.draftBranch}: ${e}`);
+        }
+        return {
+            prBranch,
+            commitHash, // Added initial commit hash
+            mergeCommitHash // Renamed from ruleEditorCommitHash
+        };
+    }
+    // ===== ASSERTIONS E2E =====
+    async assertFileContent(filePath, expectedContent, branch) {
+        const commit = await this.getFileContent(filePath, branch);
+        if (commit?.content !== expectedContent) {
+            throw new Error(`Contenu du fichier incorrect.\n` +
+                `Attendu: ${expectedContent}\n` +
+                `Reçu: ${commit?.content}`);
+        }
+    }
+    async assertPRState(branch, expectedState) {
+        const isClosed = await this.isPRClosedRobust(branch, this.config);
+        const actualState = isClosed ? 'closed' : 'open';
+        if (actualState !== expectedState) {
+            throw new Error(`État du PR incorrect. Attendu: ${expectedState}, Reçu: ${actualState}`);
+        }
+    }
+    async assertFilemerged(filePath, fromBranch, toBranch) {
+        const target = toBranch || this.config.mainBranch;
+        const isMerged = await this.isFileMerged(filePath, fromBranch, target);
+        if (!isMerged) {
+            throw new Error(`Le fichier ${filePath} n'a pas été mergé de ${fromBranch} vers ${target}`);
+        }
+    }
+    async assertBranchStructure(expectedBranches) {
+        const actualBranches = await this.getAllBranches();
+        for (const expectedBranch of expectedBranches) {
+            if (!actualBranches.includes(expectedBranch)) {
+                throw new Error(`Branche manquante: ${expectedBranch}`);
+            }
+        }
+    }
+    async assertGitHistory(expectedCommits) {
+        const log = await this.git.log({ maxCount: expectedCommits.length });
+        const actualCommits = log.all.slice(0, expectedCommits.length);
+        for (let i = 0; i < expectedCommits.length; i++) {
+            const expected = expectedCommits[i];
+            const actual = actualCommits[i];
+            if (expected.author && !actual.author_name?.includes(expected.author)) {
+                throw new Error(`Auteur de commit incorrect à l'index ${i}.\n` +
+                    `Attendu: ${expected.author}\n` +
+                    `Reçu: ${actual.author_name}`);
+            }
+        }
+    }
+    /**
+     * Retourne le chemin du repository temporaire
+     */
+    getRepositoryPath() {
+        return this.tempRepoPath;
+    }
+}
+exports.GitE2EHelper = GitE2EHelper;
+const defaultConfig = (tempDir) => {
+    if (!tempDir) {
+        throw new Error('Default should be initialized from tests/setup.after.env.ts');
+    }
+    const config = {
+        instance: (0, simple_git_1.default)({ baseDir: tempDir, binary: 'git' }),
+        repoPath: tempDir,
+        uploadPath: (0, path_1.join)(tempDir, '.assets'), // Add uploadPath to default config
+        draftBranch: 'rule-editor',
+        mainBranch: 'main',
+        validationPrefix: 'rule-validation-',
+        releasePrefix: 'rule-release-',
+        validationToken: 'closed',
+        concurrency: {
+            maxRetries: 3,
+            retryDelayMs: 100,
+            timeoutMs: 5000
+        },
+        gitNotes: {
+            namespace: 'refs/notes/pr-status',
+            enabled: true,
+            fallbackToCommit: true
+        },
+        canForce: true,
+        verbose: false
+    };
+    return config;
+};
+let defaultHelper;
+/**
+ * Factory pour créer des helpers E2E facilement
+ */
+class GitE2EFactory {
+    static getDefaultHelper() {
+        if (!defaultHelper) {
+            throw new Error('Default should be initialized from tests/setup.after.env.ts');
+        }
+        return defaultHelper;
+    }
+    /**
+     * Crée un helper E2E avec un repository temporaire
+     */
+    static async createE2EHelper(options) {
+        const tempDir = (0, path_1.join)((0, os_1.tmpdir)(), `git-e2e-test-${Math.random() * 10000 | 0}-${Math.random() * 10000 | 0}`);
+        (0, fs_1.mkdirSync)(tempDir, { recursive: true });
+        const gitConfig = { ...defaultConfig(tempDir), ...options?.customConfig };
+        gitConfig.repoPath = tempDir;
+        const testConfig = {
+            tempDir,
+            gitConfig,
+            autoCleanup: options?.autoCleanup ?? true
+        };
+        const helper = new GitE2EHelper(testConfig);
+        // Set test environment
+        process.env.NODE_ENV = 'test';
+        // Set default test values for required environment variables
+        const defaultTestEnv = {
+            DEFAULT_BRANCH_DRAFT: helper.config.draftBranch,
+            DEFAULT_BRANCH_MAIN: helper.config.mainBranch,
+            DEFAULT_BRANCH_VALIDATION_PREFIX: helper.config.validationPrefix,
+            DEFAULT_VALIDATION_TOKEN: helper.config.validationToken,
+            GIT_CONCURRENCY_MAX_RETRIES: helper.config.concurrency.maxRetries.toString(),
+            GIT_CONCURRENCY_RETRY_DELAY_MS: helper.config.concurrency.retryDelayMs.toString(),
+            GIT_CONCURRENCY_TIMEOUT_MS: helper.config.concurrency.timeoutMs.toString(),
+            GIT_NOTES_NAMESPACE: helper.config.gitNotes.namespace,
+            GIT_NOTES_ENABLED: helper.config.gitNotes.enabled.toString(),
+            GIT_NOTES_FALLBACK_TO_COMMIT: helper.config.gitNotes.fallbackToCommit.toString()
+        };
+        // Set default values if not already set
+        Object.entries(defaultTestEnv).forEach(([key, value]) => {
+            if (!process.env[key]) {
+                process.env[key] = value;
+            }
+        });
+        await helper.initTemporaryRepo();
+        defaultHelper = helper;
+        return helper;
+    }
+    /**
+     * Crée un helper E2E et exécute un test complet
+     */
+    static async runE2ETest(testName, testFunction, options) {
+        const startTime = Date.now();
+        const result = {
+            success: false,
+            duration: 0,
+            details: {
+                repositoryValid: false,
+                filesCreated: [],
+                prCreated: undefined,
+                prClosed: false,
+                merged: false
+            },
+            errors: []
+        };
+        let helper;
+        try {
+            // console.log(`🧪 Démarrage du test E2E: ${testName}`);
+            // Créer le helper
+            helper = await GitE2EFactory.createE2EHelper({
+                autoCleanup: options?.autoCleanup ?? true
+            });
+            // Valider l'état initial du repository
+            // Exécuter le test
+            await testFunction(helper);
+            // Marquer le test comme réussi
+            result.success = true;
+            result.duration = Date.now() - startTime;
+            // console.log(`✅ Test E2E réussi: ${testName} (${result.duration}ms)`);
+            return result;
+        }
+        catch (error) {
+            result.success = false;
+            result.duration = Date.now() - startTime;
+            result.errors.push(error instanceof Error ? error.message : String(error));
+            console.error(`❌ Test E2E échoué: ${testName}`);
+            console.error('Erreur:', error);
+            return result;
+        }
+        finally {
+            // Nettoyage si autoCleanup est activé
+            if (helper && (options?.autoCleanup ?? true)) {
+                try {
+                    await helper.cleanup();
+                    console.log(`🧹 Repository E2E nettoyé: ${helper.getRepositoryPath()}`);
+                }
+                catch (error) {
+                    console.warn('Erreur lors du nettoyage:', error);
+                }
+            }
+        }
+    }
+}
+exports.GitE2EFactory = GitE2EFactory;

package/dist/src/rules/git/git.health.d.ts

@@ -0,0 +1,66 @@
+import { RulesGitConfig, GitHealthStatus } from '../types';
+/**
+ * Git Repository Health Manager
+ *
+ * Manages repository health diagnostics, repairs, and maintenance operations.
+ * Provides safe operations that protect user work by only allowing destructive
+ * operations on temporary validation branches.
+ */
+export declare class GitHealthManager {
+    private git;
+    private config;
+    constructor(config?: Partial<RulesGitConfig>);
+    /**
+     * Detects and resolves any ongoing merge states in the repository
+     * This should be called before any migration operations
+     *
+     * Uses the robust gitGetBranchHealth function to diagnose issues:
+     * - git merge --abort → abandonne tout merge en cours
+     * - git reset --hard HEAD → nettoie index + working directory
+     */
+    repairRepository(branch?: string): Promise<void>;
+    /**
+     * Ensures we're on a safe branch before performing destructive operations
+     * Protects user work by refusing operations on main branches
+     */
+    private ensureSafeBranch;
+    /**
+     * Force repair when git status fails
+     * PROTECTED: Only works on validation branches to protect user work
+     */
+    private forceRepair;
+    /**
+     * Comprehensive health check for all important branches in the system
+     * Provides a complete overview of repository health
+     */
+    diagnosticRepository(): Promise<GitHealthStatus[]>;
+    /**
+     * Display a concise health summary for a branch
+     */
+    private displayHealthSummary;
+    /**
+     * Synchronizes and repairs all validation branches with the editor branch
+     *
+     * This function updates existing validation branches to stay in sync with rule-editor,
+     * not merging rule-editor into validation branches.
+     *
+     * Handles:
+     * - Échecs de synchronisation → tentative de réparation par branche
+     * - Branches inaccessibles → git checkout -f + git reset --hard HEAD (protected)
+     * - Working directory sale → git reset --hard HEAD (protected)
+     * - Retry automatique après réparation
+     * - Branches irréparables → log d'intervention manuelle
+     */
+    syncValidationBranches(): Promise<void>;
+    /**
+     * Migrates Git notes from the first commit of validation branches to the last one.
+     *
+     * Handles:
+     * - Notes déjà présentes sur HEAD → skip migration
+     * - Merge-base introuvable → skip branche avec warning
+     * - Notes orphelines sur anciens commits → copie vers HEAD + suppression
+     * - Branches sans historique de notes → ignore silencieusement
+     * - Erreurs de traitement par branche → continue avec les autres
+     */
+    migrateNotes(): Promise<void>;
+}