agentic-api 2.0.314 → 2.0.585

package/dist/src/rules/git/repo.js

@@ -53,11 +53,14 @@ exports.gitRenameFile_fs = gitRenameFile_fs;
 exports.gitRenameFile = gitRenameFile;
 exports.gitDeleteFile = gitDeleteFile;
 exports.gitGetBranchHealth = gitGetBranchHealth;
+exports.gitGetValidationBranchHealth = gitGetValidationBranchHealth;
 const fs_1 = require("fs");
 const errors_1 = require("../errors");
 const path_1 = require("path");
 const fs = __importStar(require("fs/promises"));
 const repo_tools_1 = require("./repo.tools");
+const repo_pr_1 = require("./repo.pr");
+const utils_matter_1 = require("../utils.matter");
 /**
  * Service singleton pour gérer le registre d'IDs en mémoire
  */
@@ -70,16 +73,32 @@ class IDRegistryService {
     static get() {
         return IDRegistryService.instance || (IDRegistryService.instance = new IDRegistryService());
     }
+    toString() {
+        return JSON.stringify(this.registry, null, 2);
+    }
+    clear() {
+        this.registry = null;
+        this.repoPath = '';
+        this.isDirty = false;
+    }
     /**
      * Initialise le service avec le chemin du repository
      */
     init(repoPath) {
-        // Skip if already initialized
-        if (this.registry) {
-            return;
-        }
-        if (this.repoPath !== repoPath || !this.registry) {
+        // ✅ BUGFIX: Toujours mettre à jour repoPath même si le registre existe déjà
+        // Car gitReloadIDRegistry peut être appelé avec un nouveau repoPath pour un nouveau test
+        // et le repo précédent peut avoir été nettoyé
+        if (this.repoPath !== repoPath) {
             this.repoPath = repoPath;
+            // Si le registre existe déjà, le recharger depuis le nouveau chemin
+            if (this.registry) {
+                this.registry = this.loadFromDisk();
+                this.isDirty = false;
+                return;
+            }
+        }
+        // Si le registre n'existe pas encore, le créer
+        if (!this.registry) {
             this.registry = this.loadFromDisk();
             this.isDirty = false;
         }
@@ -172,16 +191,64 @@ class IDRegistryService {
         this.isDirty = true;
         return newID;
     }
+    /**
+     * Obtient l'ID d'un fichier (peu importe la branche)
+     *
+     * Un fichier a UN SEUL ID quelque soit la branche où il se trouve.
+     * Cette fonction cherche le fichier dans toutes les branches du cache.
+     *
+     * @param file Nom du fichier (ex: 'procedure.md')
+     * @returns L'ID du fichier ou undefined si le fichier n'a pas d'ID
+     */
+    getFileID(file) {
+        if (!this.registry) {
+            return undefined;
+        }
+        // Chercher le fichier dans toutes les branches
+        for (const [cacheKey, matter] of Object.entries(this.registry.matters)) {
+            const [, cachedFile] = cacheKey.split(':');
+            if (cachedFile === file) {
+                return matter.id;
+            }
+        }
+        return undefined;
+    }
     /**
      * Vérifie si un ID appartient déjà à un fichier spécifique
+     *
+     * Un fichier garde son ID peu importe la branche, donc cette fonction
+     * cherche dans toutes les branches pour vérifier la propriété.
+     *
+     * @param id L'ID à vérifier
+     * @param file Nom du fichier
+     * @returns true si ce fichier possède cet ID
      */
-    isIDOwnedByFile(id, branch, file) {
+    isIDOwnedByFile(id, file) {
         if (!this.registry) {
             return false;
         }
-        const cacheKey = `${branch}:${file}`;
-        const cachedMatter = this.registry.matters[cacheKey];
-        return cachedMatter?.id === id;
+        // Chercher le fichier dans toutes les branches
+        const fileID = this.getFileID(file);
+        return fileID === id;
+    }
+    /**
+     * Trouve quel fichier possède un ID donné
+     *
+     * @param id L'ID à chercher
+     * @returns Le nom du fichier qui possède cet ID, ou undefined
+     */
+    getFileByID(id) {
+        if (!this.registry) {
+            return undefined;
+        }
+        // Chercher l'ID dans le cache
+        for (const [cacheKey, matter] of Object.entries(this.registry.matters)) {
+            if (matter.id === id) {
+                const [, file] = cacheKey.split(':');
+                return file;
+            }
+        }
+        return undefined;
     }
     /**
      * Enregistre un ID existant
@@ -198,7 +265,8 @@ class IDRegistryService {
         // Si l'ID est déjà utilisé
         if (this.registry.used.includes(id)) {
             // Vérifier si c'est le même fichier (pas un doublon)
-            if (branch && file && this.isIDOwnedByFile(id, branch, file)) {
+            // Note: isIDOwnedByFile() cherche maintenant dans TOUTES les branches
+            if (file && this.isIDOwnedByFile(id, file)) {
                 // Même fichier → OK, pas d'erreur
                 return;
             }
@@ -212,6 +280,10 @@ class IDRegistryService {
         if (id > this.registry.last) {
             this.registry.last = id;
         }
+        // ⚠️ IMPORTANT: Ne PAS créer d'entrée dans matters ici
+        // setMatterCache() DOIT être appelé AVANT registerExistingID() par l'appelant
+        // car registerExistingID() n'a pas le contexte complet (title, service)
+        // Si branch/file sont fournis mais que le cache n'existe pas, c'est une erreur de programmation
         this.isDirty = true;
     }
     /**
@@ -348,6 +420,9 @@ function gitGenerateNextID(config) {
     const gitConf = (0, repo_tools_1.gitLoad)(config);
     idRegistryService.init(gitConf.repoPath);
     const newID = idRegistryService.generateNextID();
+    // FIXME: Double save - gitGenerateNextID() et gitRegisterExistingID() appellent tous deux save()
+    // Refactorisation future: Retirer save() d'ici et le faire uniquement dans gitRegisterExistingID()
+    // quand matter est fourni (processus atomique: generate → setCache → register → save)
     idRegistryService.save();
     return newID;
 }
@@ -370,13 +445,16 @@ function gitGenerateNextID(config) {
  */
 function gitReloadIDRegistry(config) {
     const gitConf = (0, repo_tools_1.gitLoad)(config);
+    if (config?.reset) {
+        idRegistryService.clear();
+    }
     idRegistryService.init(gitConf.repoPath);
     idRegistryService.forceReload();
 }
 /**
  * Enregistre un ID existant dans le registre
  *
- * @param id L'ID à enregistrer
+ * @param matter Le matter contenant l'ID à enregistrer
  * @param branch Branche du fichier (optionnel, pour vérification de propriété)
  * @param file Nom du fichier (optionnel, pour vérification de propriété)
  * @param config Configuration Git optionnelle
@@ -384,11 +462,36 @@ function gitReloadIDRegistry(config) {
  *
  * **Note:** Si `branch` et `file` sont fournis, la fonction vérifie si l'ID appartient
  * déjà au même fichier. Si oui, aucune erreur n'est levée (cas de re-scan).
+ *
+ * **Note:** `setMatterCache()` est appelé automatiquement avant l'enregistrement
+ * pour garantir la cohérence du cache.
  */
-function gitRegisterExistingID(id, branch, file, config) {
+function gitRegisterExistingID(matter, branch, file, config) {
     const gitConf = (0, repo_tools_1.gitLoad)(config);
     idRegistryService.init(gitConf.repoPath);
-    idRegistryService.registerExistingID(id, branch, file);
+    // ✅ Validation: matter doit avoir id et title
+    if (!matter.id || !matter.title) {
+        throw new errors_1.GitOperationError('Le matter est invalide (id et title requis)', 'invalid_matter');
+    }
+    // ✅ IMPORTANT: Vérifier AVANT de mettre à jour le cache
+    // Si l'ID existe déjà, vérifier qu'il appartient au MÊME fichier
+    const registry = idRegistryService.getRegistry();
+    if (registry.used.includes(matter.id)) {
+        const ownerFile = idRegistryService.getFileByID(matter.id);
+        if (ownerFile && ownerFile !== file) {
+            // ID utilisé par un AUTRE fichier → Erreur
+            const error = new Error(`ID ${matter.id} est déjà utilisé`);
+            error.code = 'id_already_used';
+            throw error;
+        }
+        // Même fichier OU pas de fichier dans le cache → OK, continuer
+    }
+    // ✅ Mettre à jour le cache (maintenant qu'on sait que l'ID est valide)
+    if (branch && file) {
+        idRegistryService.setMatterCache(branch, file, matter);
+    }
+    // ✅ Enregistrer l'ID dans used[] si pas déjà dedans
+    idRegistryService.registerExistingID(matter.id, branch, file);
     idRegistryService.save();
 }
 /**
@@ -418,25 +521,61 @@ function gitIDRegistryRename(oldFile, newFile, branch, config) {
 }
 /**
  * Valide et assure qu'un matter a un ID valide
+ *
+ * **Principe d'identité stable**: Un fichier conserve son ID à travers les branches.
+ * Cette fonction cherche d'abord si le fichier a déjà un ID dans le registre
+ * (peu importe la branche), et le réutilise pour garantir la cohérence.
+ *
  * @param matter Le matter à valider/compléter
  * @param config Configuration Git optionnelle
+ * @param branch Branche du fichier (optionnel, peut être undefined lors de createPullRequest)
+ * @param file Nom du fichier (requis pour chercher l'ID existant)
  * @returns Le matter mis à jour avec un ID valide
  */
-function gitEnsureMatterID(matter, config) {
-    // Si ID existe et est valide
+function gitEnsureMatterID(matter, config, branch, file) {
+    const gitConf = (0, repo_tools_1.gitLoad)(config);
+    idRegistryService.init(gitConf.repoPath);
+    // ✅ NOUVEAU: Chercher d'abord l'ID existant du fichier (peu importe la branche)
+    const existingFileID = file ? idRegistryService.getFileID(file) : undefined;
+    if (existingFileID) {
+        // Le fichier a déjà un ID → le réutiliser pour garantir la cohérence
+        matter.id = existingFileID;
+        // Mettre à jour le cache si branch est définie (sinon ce sera fait plus tard)
+        if (branch && file && matter.title) {
+            idRegistryService.setMatterCache(branch, file, {
+                id: matter.id,
+                title: matter.title,
+                service: matter.service
+            });
+        }
+        return matter;
+    }
+    // Si matter a un ID fourni manuellement (ex: import ou test)
     // FIXME 999 should be a constant in config
     if (matter.id && typeof matter.id === 'number' && matter.id > 999) {
         try {
-            // Pas de branch/file car utilisé pour nouveaux fichiers ou contexte inconnu
-            gitRegisterExistingID(matter.id, undefined, undefined, config);
+            // Essayer d'enregistrer cet ID
+            gitRegisterExistingID(matter, branch, file, config);
             return matter;
         }
         catch (error) {
-            // ID déjà utilisé → générer un nouveau (silencieux, géré par le caller)
+            // ID déjà utilisé par un AUTRE fichier → générer un nouveau
+            // (Si même fichier, registerExistingID ne lève pas d'erreur)
         }
     }
-    // Générer un nouvel ID
+    // Générer un nouvel ID (si aucun ID fourni ou ID invalide)
     matter.id = gitGenerateNextID(config);
+    // FIXME: Double save ici - gitGenerateNextID() fait save() puis gitRegisterExistingID() fait save() aussi
+    // Refactorisation future: Retirer save() de gitGenerateNextID() et le faire uniquement dans gitRegisterExistingID()
+    // quand matter est fourni (processus atomique: generate → setCache → register → save)
+    // ✅ Mettre à jour le cache avec le nouvel ID (seulement si branch est définie)
+    if (branch && file && matter.title) {
+        idRegistryService.setMatterCache(branch, file, {
+            id: matter.id,
+            title: matter.title,
+            service: matter.service
+        });
+    }
     return matter;
 }
 /**
@@ -862,13 +1001,20 @@ async function gitCheckConfiguration(git) {
     return check;
 }
 /**
- * Crée un fichier dans la branche draft (opération bas niveau)
- * @param git Instance Git
+ * Crée ou modifie un fichier dans une branche Git et fait un commit automatique
+ *
+ * @param git Instance SimpleGit
  * @param filePath Chemin du fichier
  * @param PR Nom de la branche de Pull Request
  * @param content Contenu du fichier
- * @param user Utilisateur qui effectue l'opération
- * @param config Configuration Git (optionnel, utilise la config globale)
+ * @param user Utilisateur qui fait le commit
+ * @param config Configuration Git optionnelle
+ * @returns Historique du commit créé
+ *
+ * @fixme Ajouter un paramètre optionnel `commitMessage?: string` pour permettre de personnaliser
+ *        le message de commit au lieu d'utiliser toujours `commit: ${filePath}` par défaut.
+ *        Cela permettrait aux callers de spécifier des messages plus descriptifs.
+ *
  * @throws GitOperationError si la création échoue
  */
 async function gitCreateOrEditFile(git, filePath, PR, content, user, config) {
@@ -882,24 +1028,52 @@ async function gitCreateOrEditFile(git, filePath, PR, content, user, config) {
         if (gitConf.withID) {
             try {
                 // Import dynamique pour éviter les dépendances circulaires
-                const { matterParse, matterSerialize } = await Promise.resolve().then(() => __importStar(require('../utils.matter')));
-                const parsed = matterParse(content);
+                const parsed = (0, utils_matter_1.matterParse)(content);
                 if (gitConf.strictID) {
                     // Mode strict : valider que l'ID existe et est correct
                     validateMatter(parsed.matter);
+                    // ✅ gitRegisterExistingID() appelle maintenant setMatterCache() automatiquement si matter est fourni
                     // Enregistrer l'ID existant
                     // ✅ Passer branch (PR) et file (filePath) pour vérifier propriété
-                    gitRegisterExistingID(parsed.matter.id, PR, filePath, gitConf);
+                    gitRegisterExistingID(parsed.matter, PR, filePath, gitConf);
                 }
                 else {
                     // Mode permissif : générer l'ID si manquant
-                    parsed.matter = gitEnsureMatterID(parsed.matter, gitConf);
-                    // Re-sérialiser avec l'ID mis à jour
-                    content = matterSerialize(parsed.content, parsed.matter);
+                    // ✅ IMPORTANT: Ne PAS ré-assigner l'ID s'il est déjà valide
+                    // Le contenu a peut-être déjà été traité par gitEnsureMatterID() dans le caller
+                    const hasValidID = parsed.matter.id &&
+                        typeof parsed.matter.id === 'number' &&
+                        parsed.matter.id > 999;
+                    if (!hasValidID) {
+                        // Seulement si l'ID est manquant ou invalide
+                        parsed.matter = gitEnsureMatterID(parsed.matter, gitConf, PR, filePath);
+                        // Re-sérialiser avec l'ID mis à jour
+                        content = (0, utils_matter_1.matterSerialize)(parsed.content, parsed.matter);
+                    }
+                    else {
+                        // ✅ L'ID existe déjà : gitRegisterExistingID() appelle maintenant setMatterCache() automatiquement
+                        try {
+                            gitRegisterExistingID(parsed.matter, PR, filePath, gitConf);
+                        }
+                        catch (error) {
+                            // Si l'ID est déjà utilisé par un autre fichier, générer un nouvel ID
+                            if (error.code === 'id_already_used') {
+                                // En mode non-strict, générer un nouvel ID si doublon détecté
+                                parsed.matter = gitEnsureMatterID(parsed.matter, gitConf, PR, filePath);
+                                content = (0, utils_matter_1.matterSerialize)(parsed.content, parsed.matter);
+                                // ✅ Ne pas propager l'erreur, continuer avec le nouvel ID généré
+                            }
+                            else {
+                                throw error;
+                            }
+                        }
+                    }
                 }
             }
             catch (error) {
-                if (error.code === 'id_already_used') {
+                // En mode strict, propager l'erreur id_already_used
+                // En mode permissif, cette erreur devrait déjà être gérée dans le bloc ci-dessus
+                if (error.code === 'id_already_used' && gitConf.strictID) {
                     throw new errors_1.GitOperationError(`Impossible de créer le fichier: ${error.message}`, 'duplicate_id', { filePath, error });
                 }
                 // Propager les autres erreurs de validation
@@ -923,13 +1097,15 @@ async function gitCreateOrEditFile(git, filePath, PR, content, user, config) {
         //
         // without note the branche is not a valid PR branch
         const oldNote = await (0, repo_tools_1.gitReadNote)(git, PR, gitConf.gitNotes.namespace, 10);
+        if (oldNote && gitConf.verbose) {
+            console.debug('[gitCreateOrEditFile] metadata.files before update:', oldNote.files);
+        }
         const commit = await _writeFileAndCommit(git, filePath, content, user, gitConf, `commit: ${filePath}`);
         // ✅ Mettre à jour le cache du matter après sauvegarde
         // NOTE: Le cache est TOUJOURS mis à jour, indépendamment de withID
         // C'est une opération de cache, pas une validation
         try {
-            const { matterParse } = await Promise.resolve().then(() => __importStar(require('../utils.matter')));
-            const parsed = matterParse(content);
+            const parsed = (0, utils_matter_1.matterParse)(content);
             idRegistryService.init(gitConf.repoPath);
             idRegistryService.setMatterCache(PR, filePath, {
                 id: parsed.matter.id,
@@ -958,11 +1134,15 @@ async function gitCreateOrEditFile(git, filePath, PR, content, user, config) {
         }
         // Determine the current head after the commit attempt.
         const newHead = (await git.revparse(['HEAD'])).trim();
-        const newFiles = await (0, repo_tools_1.gitGetDiffFiles)(git, PR, oldNote.mergeBase);
+        let newFiles = await (0, repo_tools_1.gitGetDiffFiles)(git, PR, oldNote.mergeBase);
+        newFiles = await sanitizePRFiles(git, newFiles, PR);
         const updatedNote = {
             ...oldNote,
             files: newFiles,
         };
+        if (gitConf.verbose) {
+            console.debug('[gitCreateOrEditFile] metadata.files after update:', updatedNote.files);
+        }
         // Write the note to the current HEAD of the PR branch.
         // If no commit was made, this overwrites the note on oldHead.
         // If a new commit was made, this writes the note on newHead.
@@ -1165,12 +1345,24 @@ async function gitRenameFile(git, oldFileName, newFileName, branch, user, config
         //
         //FIXME: add a check about the branch (file can be NEW and on branch)
         const fullOldPath = (0, path_1.join)(gitConf.uploadPath, oldFileName);
+        let result;
         if ((0, fs_1.existsSync)(fullOldPath)) {
-            return await gitRenameFile_fs(git, oldFileName, newFileName, branch, user, config);
+            result = await gitRenameFile_fs(git, oldFileName, newFileName, branch, user, config);
         }
         else {
-            return await gitRenameFile_git(git, oldFileName, newFileName, branch, user, config);
+            result = await gitRenameFile_git(git, oldFileName, newFileName, branch, user, config);
+            if (branch !== 'NEW' && branch.startsWith(gitConf.validationPrefix)) {
+                try {
+                    await (0, repo_pr_1.gitPRReplaceFile)(git, branch, { remove: oldFileName, add: newFileName }, gitConf);
+                }
+                catch (metadataError) {
+                    if (gitConf.verbose) {
+                        console.warn('⚠️ Failed to update PR metadata after rename:', metadataError);
+                    }
+                }
+            }
         }
+        return result;
     }
     catch (error) {
         // Pour les vraies branches Git, ne pas faire de fallback filesystem
@@ -1398,6 +1590,81 @@ async function gitGetBranchHealth(git, branch) {
         (health.clean || (health.modifiedFiles === 0 && health.stagedFiles === 0));
     return health;
 }
+/**
+ * Version optimisée de gitGetBranchHealth pour les branches de validation
+ *
+ * Cette fonction utilise une approche en cascade pour diagnostiquer rapidement
+ * l'état d'une branche de validation sans effectuer de checkout coûteux.
+ *
+ * Tests effectués dans l'ordre (arrêt au premier échec) :
+ * 1. Branche existe ? (git rev-parse --verify)
+ * 2. Note Git présente sur HEAD ? (gitReadNote avec maxCommit=1)
+ * 3. Note correspond au bon PR ? (note.id === prNumber)
+ *
+ * Avantages :
+ * - ✅ Pas de checkout (gain 80-90% performance)
+ * - ✅ Lecture directe du HEAD sans changer de branche
+ * - ✅ Tests cascade (arrêt dès qu'un problème est détecté)
+ * - ✅ Optimisé pour branches temporaires (validations)
+ *
+ * @param git Instance SimpleGit
+ * @param branch Nom de la branche de validation à diagnostiquer
+ * @param config Configuration Git optionnelle
+ * @returns GitHealthStatus avec diagnostic optimisé
+ */
+async function gitGetValidationBranchHealth(git, branch, config) {
+    const gitConfig = config || (0, repo_tools_1.gitLoad)();
+    const health = {
+        branch,
+        exists: false,
+        accessible: false,
+        clean: true, // Par défaut OK pour validation (pas de working dir check)
+        mergeInProgress: false,
+        conflictedFiles: 0,
+        modifiedFiles: 0,
+        untrackedFiles: 0,
+        stagedFiles: 0,
+        indexReadable: true,
+        healthy: false,
+        issues: [],
+        recommendations: []
+    };
+    try {
+        // 1. CASCADE: Vérifier existence (très rapide, sans checkout)
+        const branchExists = await git.raw(['rev-parse', '--verify', branch])
+            .then(() => true)
+            .catch(() => false);
+        if (!branchExists) {
+            health.issues.push(`Branche '${branch}' n'existe pas`);
+            health.recommendations.push(`Créer la branche ou vérifier le nom`);
+            return health;
+        }
+        health.exists = true;
+        health.accessible = true; // Si rev-parse OK, branche accessible
+        // 2. CASCADE: Vérifier note sur HEAD (rapide, sans checkout)
+        const headCommit = await git.raw(['rev-parse', branch]).then(s => s.trim());
+        const note = await (0, repo_tools_1.gitReadNote)(git, headCommit, gitConfig.gitNotes.namespace, 1);
+        if (!note) {
+            health.issues.push(`Pas de note Git sur HEAD de '${branch}'`);
+            health.recommendations.push(`Note perdue, utiliser git-notes-list-lost.sh pour la localiser`);
+            return health;
+        }
+        // 3. CASCADE: Vérifier que la note correspond au PR
+        const prNumber = parseInt(branch.split('-').pop() || '0', 10);
+        if (note.id !== prNumber) {
+            health.issues.push(`Note incorrecte: ID=${note.id}, attendu PR=${prNumber}`);
+            health.recommendations.push(`Corriger la note ou supprimer la branche`);
+            return health;
+        }
+        // ✅ Tous les tests essentiels passés
+        health.healthy = true;
+    }
+    catch (error) {
+        health.issues.push(`Erreur diagnostic: ${error.message}`);
+        health.recommendations.push(`Vérifier l'état du dépôt Git`);
+    }
+    return health;
+}
 /**
  * Fonction helper pour créer un statut unhealthy
  */
@@ -1422,9 +1689,7 @@ function createUnhealthyStatus(branch, exists, accessible, clean, mergeInProgres
  * Vérifie si un merge est en cours en regardant les fichiers Git
  */
 async function checkMergeInProgress(repoPath) {
-    const { existsSync } = await Promise.resolve().then(() => __importStar(require('fs')));
-    const { join } = await Promise.resolve().then(() => __importStar(require('path')));
-    const gitDir = join(repoPath, '.git');
+    const gitDir = (0, path_1.join)(repoPath, '.git');
     const mergeFiles = [
         'MERGE_HEAD',
         'MERGE_MODE',
@@ -1432,5 +1697,27 @@ async function checkMergeInProgress(repoPath) {
         'CHERRY_PICK_HEAD',
         'REVERT_HEAD'
     ];
-    return mergeFiles.some(file => existsSync(join(gitDir, file)));
+    return mergeFiles.some(file => (0, fs_1.existsSync)((0, path_1.join)(gitDir, file)));
+}
+async function sanitizePRFiles(git, files, branch) {
+    if (!files || files.length === 0) {
+        return [];
+    }
+    const checks = await Promise.all(files.map(async (file) => ({
+        file,
+        exists: await (0, repo_tools_1.gitFileExistsInBranch)(git, file, branch)
+    })));
+    const sanitized = [];
+    const seen = new Set();
+    for (const { file, exists } of checks) {
+        if (!exists) {
+            continue;
+        }
+        if (seen.has(file)) {
+            continue;
+        }
+        seen.add(file);
+        sanitized.push(file);
+    }
+    return sanitized;
 }

package/dist/src/rules/git/repo.pr.d.ts

@@ -79,6 +79,14 @@ export declare function gitGetAllPR(git: SimpleGit, options?: {
  */
 export declare function gitGetClosedPRs(git: SimpleGit, gitConfig: RulesGitConfig): Promise<PRInfo[]>;
 export declare function gitLoadPR(git: SimpleGit, branch: string): Promise<PRInfo>;
+/**
+ * Remplace explicitement un nom de fichier dans les métadonnées d'une PR.
+ * Utilisé pour refléter immédiatement les renames sans dépendre de git diff.
+ */
+export declare function gitPRReplaceFile(git: SimpleGit, branch: string, options?: {
+    remove?: string;
+    add?: string;
+}, config?: RulesGitConfig): Promise<void>;
 export declare function gitPRUpdateComments(git: SimpleGit, branch: string, details: RulePullRequestDetails, config?: RulesGitConfig): Promise<PRInfo>;
 /**
  * DEPRECATED: use gitClosePRRobust instead