agentic-api 2.0.491 → 2.0.585

package/dist/src/rag/rag.manager.js

@@ -53,12 +53,19 @@ class RAGManager {
         DEFAULT_RAG_INSTANCE[defaultName] = this;
     }
     static get(config) {
-        // Vérifier si une instance existe déjà pour ce baseDir
-        if (DEFAULT_RAG_INSTANCE[config.baseDir]) {
-            return DEFAULT_RAG_INSTANCE[config.baseDir];
-        }
-        // Créer une nouvelle instance
-        return new RAGManager(config);
+        // Normaliser le baseDir pour éviter les doublons dus aux trailing slashes
+        // ou aux variations de paths (relatif/absolu, symlinks, etc.)
+        const normalizedBaseDir = path_1.default.resolve(config.baseDir).replace(/\/+$/, '');
+        // Vérifier si une instance existe déjà pour ce baseDir normalisé
+        if (DEFAULT_RAG_INSTANCE[normalizedBaseDir]) {
+            return DEFAULT_RAG_INSTANCE[normalizedBaseDir];
+        }
+        // Créer une nouvelle instance avec le baseDir normalisé
+        const normalizedConfig = {
+            ...config,
+            baseDir: normalizedBaseDir
+        };
+        return new RAGManager(normalizedConfig);
     }
     /**
      * Nettoie le cache des instances (utile pour les tests)
@@ -495,18 +502,31 @@ class RAGManager {
         if (!entry) {
             throw new Error(`RAG '${name}' n'existe pas`);
         }
-        // if (status.status !== 'building') {
-        //   throw new Error(`RAG '${name}' n'est pas en construction (status: ${status.status})`);
-        // }
         const buildPath = entry.configPath;
         if (!(0, fs_1.existsSync)(buildPath)) {
             throw new Error(`Le dossier de construction n'existe pas: ${buildPath}`);
         }
         const filePath = path_1.default.join(buildPath, filename);
-        const shaPath = path_1.default.join(buildPath, filename + '.sha');
-        // ✅ Sauvegarder le fichier
+        // ✅ Sauvegarder le fichier source uniquement
+        // Le .sha est écrit par markDocumentProcessed() APRÈS génération de .enhanced.md et .query.json
         (0, fs_1.writeFileSync)(filePath, content, 'utf8');
-        // ✅ Sauvegarder le fingerprint
+    }
+    /**
+     * Marque un document comme entièrement traité (enhanced + query.json générés)
+     * Le .sha est écrit APRÈS le traitement complet pour garantir la cohérence
+     *
+     * @param name Nom du RAG
+     * @param filename Nom du fichier (ex: 'procedure.md')
+     * @param content Contenu du document traité
+     */
+    markDocumentProcessed(name, filename, content) {
+        const entry = this.getEntry(name);
+        if (!entry) {
+            throw new Error(`RAG '${name}' n'existe pas`);
+        }
+        const buildPath = entry.configPath;
+        const shaPath = path_1.default.join(buildPath, filename + '.sha');
+        // ✅ Sauvegarder le fingerprint pour marquer le document comme traité
         const sha = (0, usecase_1.calculateFingerprint)(content);
         (0, fs_1.writeFileSync)(shaPath, sha, 'utf8');
     }
@@ -686,6 +706,72 @@ class RAGManager {
         const queryFile = baseName + '.query.json';
         return (0, usecase_1.loadUseCases)(queryFile, { baseDir: configPath });
     }
+    /**
+     * Charge tous les use cases de tous les documents d'un RAG
+     *
+     * Utilise le fichier rag-metadata.json pour obtenir la liste des documents valides
+     * puis charge chaque fichier .query.json correspondant
+     *
+     * @param name Nom du RAG
+     * @returns Objet contenant tous les use cases par document
+     *
+     * @example
+     * ```typescript
+     * const allQueries = ragManager.loadAllUseCases('my-rag');
+     * console.log(`${Object.keys(allQueries.documents).length} documents avec use cases`);
+     * console.log(`${allQueries.totalQueries} questions au total`);
+     * ```
+     */
+    loadAllUseCases(name) {
+        const entry = this.getEntry(name);
+        if (!entry) {
+            throw new Error(`RAG '${name}' n'existe pas`);
+        }
+        //
+        // Charger le metadata pour obtenir la liste des documents
+        const metadataFile = path_1.default.join(entry.configPath, types_1.RAG_FILES.METADATA);
+        if (!(0, fs_1.existsSync)(metadataFile)) {
+            throw new Error(`Fichier metadata manquant: ${metadataFile}`);
+        }
+        let metadata;
+        try {
+            metadata = JSON.parse((0, fs_1.readFileSync)(metadataFile, 'utf8'));
+        }
+        catch (error) {
+            throw new Error(`Erreur lors du chargement du metadata: ${error}`);
+        }
+        //
+        // Extraire les filenames uniques depuis metadata.documents
+        const uniqueFilenames = new Set();
+        for (const docRef of Object.values(metadata.documents)) {
+            if (docRef.filename) {
+                uniqueFilenames.add(docRef.filename);
+            }
+        }
+        //
+        // Charger les use cases pour chaque document
+        const documents = {};
+        let totalQueries = 0;
+        const filenames = [];
+        for (const filename of uniqueFilenames) {
+            const baseName = filename.replace(/\.md$/, '');
+            const queryFile = path_1.default.join(entry.configPath, baseName + '.query.json');
+            if ((0, fs_1.existsSync)(queryFile)) {
+                try {
+                    const queries = JSON.parse((0, fs_1.readFileSync)(queryFile, 'utf8'));
+                    documents[filename] = queries;
+                    totalQueries += queries.queries?.length || 0;
+                    filenames.push(filename);
+                }
+                catch (error) {
+                    //
+                    // Log l'erreur mais continue avec les autres documents
+                    console.warn(`⚠️ Erreur chargement use cases pour ${filename}:`, error.message);
+                }
+            }
+        }
+        return { documents, totalQueries };
+    }
     /**
      * Construit un RAG de manière atomique
      *
@@ -881,28 +967,34 @@ class RAGManager {
      */
     async delete(name, archiveFlag = true) {
         if (!this.exists(name)) {
-            throw new Error(`RAG '${name}' n'existe pas`);
+            console.warn(`⚠️ RAG '${name}' n'existe pas, skip delete`);
+            return new Error(`RAG '${name}' n'existe pas`);
         }
-        const entry = this.getEntry(name);
-        const registry = this.getRegistry();
-        // Archiver si demandé
-        if (archiveFlag) {
-            await this.archive(name);
-        }
-        else if ((0, fs_1.existsSync)(entry.configPath)) {
-            (0, fs_1.rmSync)(entry.configPath, { recursive: true, force: true });
-        }
-        // Supprimer du registre
-        delete registry.registries[name];
-        // Supprimer de la map des embeddings chargés
-        this.loadedEmbeddings.delete(name);
-        // Changer le défaut si nécessaire
-        if (registry.defaultName === name) {
-            const remainingRAGs = Object.keys(registry.registries);
-            registry.defaultName = remainingRAGs.length > 0 ? remainingRAGs[0] : 'RAGRegistry';
+        try {
+            const entry = this.getEntry(name);
+            const registry = this.getRegistry();
+            // Archiver si demandé
+            if (archiveFlag) {
+                await this.archive(name);
+            }
+            else if ((0, fs_1.existsSync)(entry.configPath)) {
+                (0, fs_1.rmSync)(entry.configPath, { recursive: true, force: true });
+            }
+            // Supprimer du registre
+            delete registry.registries[name];
+            // Supprimer de la map des embeddings chargés
+            this.loadedEmbeddings.delete(name);
+            // Changer le défaut si nécessaire
+            if (registry.defaultName === name) {
+                const remainingRAGs = Object.keys(registry.registries);
+                registry.defaultName = remainingRAGs.length > 0 ? remainingRAGs[0] : 'RAGRegistry';
+            }
+            this.saveRegistry(registry);
+            console.log(`✅ RAG supprimé: ${name}`);
+        }
+        catch (error) {
+            return error;
         }
-        this.saveRegistry(registry);
-        console.log(`✅ RAG supprimé: ${name}`);
     }
     /**
      * Renomme un document dans un RAG existant
@@ -1041,7 +1133,8 @@ class RAGManager {
         }
     }
     /**
-     * Renomme un RAG existant
+     * Renomme un RAG existant (nom dans le registre uniquement)
+     * Le dossier physique n'est PAS modifié, seul le nom dans la config change.
      *
      * @param from Nom actuel du RAG
      * @param to Nouveau nom du RAG
@@ -1051,6 +1144,7 @@ class RAGManager {
      * @example
      * ```typescript
      * await ragManager.rename('old-name', 'new-name', 'Description mise à jour');
+     * // Le dossier reste /path/to/old-name mais le RAG s'appelle 'new-name'
      * ```
      */
     async rename(from, to, description) {
@@ -1073,20 +1167,14 @@ class RAGManager {
             throw new Error(`Le nom '${to}' est réservé et ne peut pas être utilisé`);
         }
         const sourceEntry = this.getEntry(from);
-        const sourcePath = sourceEntry.configPath;
-        const destPath = path_1.default.join(this.config.baseDir, to);
         try {
-            // Renommer le dossier physique
-            if ((0, fs_1.existsSync)(sourcePath)) {
-                (0, fs_1.renameSync)(sourcePath, destPath);
-                if (this.config.verbose)
-                    console.log(`📁 Dossier renommé: ${sourcePath} → ${destPath}`);
-            }
-            // Mettre à jour le registre
+            //
+            // Ne PAS renommer le dossier physique - juste le nom dans le registre
+            // Le configPath reste inchangé (pointe vers le même dossier)
             const registry = this.getRegistry();
             registry.registries[to] = {
                 name: to,
-                configPath: destPath,
+                configPath: sourceEntry.configPath, // ✅ Garde le même chemin
                 status: sourceEntry.status,
                 description: description || sourceEntry.description
             };
@@ -1100,12 +1188,10 @@ class RAGManager {
             if (embeddingData) {
                 this.loadedEmbeddings.set(to, embeddingData);
                 this.loadedEmbeddings.delete(from);
-                // Notifier l'embedding de se mettre à jour avec le nouveau chemin
-                this.notifyUpdate(to);
             }
             // Mettre à jour le cache
             this.saveRegistry(registry);
-            console.log(`✅ RAG renommé: ${from} → ${to}`);
+            console.log(`✅ RAG renommé: ${from} → ${to} (dossier inchangé: ${sourceEntry.configPath})`);
         }
         catch (error) {
             console.error(`❌ Erreur lors du renommage de '${from}' en '${to}':`, error);

package/dist/src/rag/types.d.ts

@@ -5,6 +5,8 @@ export declare const RAG_FILES: {
     readonly QUERIES: "rag-queries.json";
 };
 export interface RAGConfig {
+    /** Provider de l'embedding (default openai) */
+    provider?: string;
     /** Répertoire de base pour les documents et index */
     baseDir: string;
     /** Nom du fichier de vecteurs (sans extension) */

package/dist/src/rag/usecase.js

@@ -132,25 +132,22 @@ async function extractAndSaveDocumentUseCases(document, baseDir, version, tag, o
             const existingQueries = JSON.parse((0, fs_1.readFileSync)(queryFile, 'utf8'));
             // Comparer le fingerprint
             if (existingQueries.fingerprint === fingerprint) {
-                if (verbose) {
-                    console.log(`⏭️ Use cases à jour (fingerprint identique): ${document.filename}`);
-                }
+                console.log(`⏭️ Skip queries: ${document.filename}`);
                 return existingQueries;
             }
-            else if (verbose) {
-                console.log(`🔄 Contenu modifié (fingerprint différent): ${document.filename}`);
-            }
+            console.log(`🔄 Source modifiée queries: ${document.filename}`);
         }
         catch (error) {
             // Si erreur de lecture, on continue avec l'extraction
-            if (verbose) {
-                console.warn(`⚠️ Erreur lecture use cases existants: ${error}`);
-            }
+            console.warn(`⚠️ Erreur lecture use cases: ${error}`);
         }
     }
     // Extraction nécessaire (fichier inexistant, fingerprint différent, ou force=true)
-    if (verbose && force) {
-        console.log(`🔄 Re-extraction forcée: ${document.filename}`);
+    if (force) {
+        console.log(`🔄 Force queries: ${document.filename}`);
+    }
+    else {
+        console.log(`✨ Nouveau queries: ${document.filename}`);
     }
     const { queries, cost } = await extractDocumentUseCases(document);
     const docQueries = {

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

@@ -551,6 +551,44 @@ class GitHealthManager {
         ];
         let fixed = 0;
         const fixedFiles = new Set();
+        // ✅ ÉTAPE CRITIQUE: Charger le cache pour toutes les branches avant la réparation
+        // Cela permet à getFileID() de trouver l'ID existant du fichier
+        if (!dryRun && filesToFix.length > 0) {
+            console.log(`   🔍 Chargement du cache pour toutes les branches...`);
+            const allBranches = await (0, git_1.gitGetAllBranches)(this.git);
+            const uniqueFiles = new Set();
+            for (const fileRef of filesToFix) {
+                const [, ...fileParts] = fileRef.split(':');
+                const file = fileParts.join(':');
+                uniqueFiles.add(file);
+            }
+            // Mettre en cache la liste des fichiers par branche pour éviter les appels répétés
+            const branchFilesCache = new Map();
+            for (const branch of allBranches) {
+                try {
+                    const filesInBranch = await (0, git_1.gitListFilesInBranch)(this.git, branch);
+                    branchFilesCache.set(branch, filesInBranch);
+                }
+                catch (e) {
+                    // Ignorer silencieusement les erreurs (branche peut être inaccessible)
+                    branchFilesCache.set(branch, []);
+                }
+            }
+            // Charger le cache pour chaque fichier dans les branches où il existe
+            for (const file of uniqueFiles) {
+                for (const branch of allBranches) {
+                    try {
+                        const filesInBranch = branchFilesCache.get(branch) || [];
+                        if (filesInBranch.includes(file)) {
+                            await (0, git_1.gitFileStrictMatter)(this.git, file, branch, this.config);
+                        }
+                    }
+                    catch (e) {
+                        // Ignorer silencieusement les erreurs (fichier peut ne pas exister)
+                    }
+                }
+            }
+        }
         for (const fileRef of filesToFix) {
             // Éviter de réparer deux fois le même fichier
             if (fixedFiles.has(fileRef)) {
@@ -570,11 +608,19 @@ class GitHealthManager {
                     // Parser le matter complet
                     const parsed = (0, utils_matter_1.matterParse)(fileData.content);
                     const { matter: fullMatter, content } = parsed;
-                    // Générer un nouvel ID si manquant
-                    if (!fullMatter.id || typeof fullMatter.id !== 'number' || fullMatter.id <= 999) {
-                        fullMatter.id = (0, git_1.gitGenerateNextID)(this.config);
-                        console.log(`   🔧 ${file}: Génération d'un nouvel ID: ${fullMatter.id}`);
+                    // ✅ CORRECTION: Utiliser gitEnsureMatterID() pour réutiliser l'ID existant du fichier
+                    // Si le fichier existe déjà dans une autre branche, son ID sera réutilisé
+                    // Sinon, un nouvel ID sera généré automatiquement
+                    const matterWithID = (0, git_1.gitEnsureMatterID)(fullMatter, this.config, branchName, file);
+                    if (matterWithID.id !== fullMatter.id) {
+                        if (fullMatter.id && fullMatter.id > 999) {
+                            console.log(`   🔧 ${file}: ID ${fullMatter.id} remplacé par ID existant ${matterWithID.id}`);
+                        }
+                        else {
+                            console.log(`   🔧 ${file}: Nouvel ID assigné: ${matterWithID.id}`);
+                        }
                     }
+                    fullMatter.id = matterWithID.id;
                     // Générer un titre si manquant (basé sur le nom du fichier ou le premier titre de section)
                     if (!fullMatter.title || fullMatter.title.trim() === '') {
                         // Essayer d'extraire le premier titre de section (# Title)
@@ -591,6 +637,15 @@ class GitHealthManager {
                     }
                     // Re-sérialiser et sauvegarder
                     const updatedContent = (0, utils_matter_1.matterSerialize)(content, fullMatter);
+                    // ✅ CRITIQUE: Vérifier si le contenu a réellement changé avant de créer un commit
+                    // Si le contenu n'a pas changé, ne pas créer de commit pour éviter de déplacer les notes Git
+                    if (updatedContent === fileData.content) {
+                        // Le contenu n'a pas changé, juste mettre à jour le cache sans créer de commit
+                        console.log(`   ℹ️  ${file}: Aucun changement nécessaire (ID ${fullMatter.id} déjà correct)`);
+                        fixed++;
+                        fixedFiles.add(fileRef);
+                        continue;
+                    }
                     // ✅ IMPORTANT: Désactiver withID car l'ID est déjà généré et enregistré
                     // Évite la double validation qui cause "ID déjà utilisé"
                     await (0, repo_1.gitCreateOrEditFile)(this.git, file, branchName, updatedContent, { name: 'GitHealthManager', email: 'health@system' }, { ...this.config, canForce: true, withID: false });

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

@@ -195,13 +195,20 @@ export declare function gitShowConfiguration(git: SimpleGit): Promise<any>;
  */
 export declare function gitCheckConfiguration(git?: SimpleGit): Promise<any>;
 /**
- * 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
  */
 export declare function gitCreateOrEditFile(git: SimpleGit, filePath: string, PR: string, content: string, user: RuleUser, config?: RulesGitConfig): Promise<GitCommitHistory>;

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

@@ -59,6 +59,8 @@ 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
  */
@@ -561,7 +563,7 @@ function gitEnsureMatterID(matter, config, branch, file) {
             // (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()
@@ -999,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) {
@@ -1019,8 +1028,7 @@ 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);
@@ -1040,7 +1048,7 @@ async function gitCreateOrEditFile(git, filePath, PR, content, user, config) {
                         // 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 = matterSerialize(parsed.content, parsed.matter);
+                        content = (0, utils_matter_1.matterSerialize)(parsed.content, parsed.matter);
                     }
                     else {
                         // ✅ L'ID existe déjà : gitRegisterExistingID() appelle maintenant setMatterCache() automatiquement
@@ -1052,7 +1060,7 @@ async function gitCreateOrEditFile(git, filePath, PR, content, user, config) {
                             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 = matterSerialize(parsed.content, parsed.matter);
+                                content = (0, utils_matter_1.matterSerialize)(parsed.content, parsed.matter);
                                 // ✅ Ne pas propager l'erreur, continuer avec le nouvel ID généré
                             }
                             else {
@@ -1089,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,
@@ -1124,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.
@@ -1331,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
@@ -1663,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',
@@ -1673,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

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

@@ -40,6 +40,7 @@ exports.gitGetPRMetadata = gitGetPRMetadata;
 exports.gitGetAllPR = gitGetAllPR;
 exports.gitGetClosedPRs = gitGetClosedPRs;
 exports.gitLoadPR = gitLoadPR;
+exports.gitPRReplaceFile = gitPRReplaceFile;
 exports.gitPRUpdateComments = gitPRUpdateComments;
 exports.gitClosePR = gitClosePR;
 exports.gitClosePRRobust = gitClosePRRobust;
@@ -321,7 +322,7 @@ async function gitLoadPR(git, branch) {
         if (!metadata) {
             throw new errors_1.GitOperationError(`PR not found for branch ${branch}`, 'pr_load', { branch });
         }
-        const files = await (0, repo_tools_1.gitGetDiffFiles)(git, branch, metadata?.mergeBase, '.md');
+        const files = metadata.files || (await (0, repo_tools_1.gitGetDiffFiles)(git, branch, metadata?.mergeBase, '.md'));
         // Récupérer les infos du dernier commit de la branche
         const log = await git.log({ from: branch, to: branch, maxCount: 1 });
         const lastCommit = log.latest;
@@ -341,6 +342,49 @@ async function gitLoadPR(git, branch) {
         throw new errors_1.GitOperationError(`Failed to retrieve PR: ${error}`, 'pr_load');
     }
 }
+/**
+ * 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.
+ */
+async function gitPRReplaceFile(git, branch, options = {}, config) {
+    const { remove, add } = options;
+    if (!remove && !add) {
+        return;
+    }
+    const gitConf = (0, repo_tools_1.gitLoad)(config);
+    const metadata = await gitGetPRMetadata(git, branch, config);
+    if (!metadata) {
+        return;
+    }
+    const currentFiles = Array.isArray(metadata.files) ? metadata.files : [];
+    const seen = new Set();
+    const nextFiles = [];
+    for (const file of currentFiles) {
+        if (!file) {
+            continue;
+        }
+        if (remove && file === remove) {
+            continue;
+        }
+        if (seen.has(file)) {
+            continue;
+        }
+        seen.add(file);
+        nextFiles.push(file);
+    }
+    if (add && !seen.has(add)) {
+        nextFiles.push(add);
+        seen.add(add);
+    }
+    const changed = currentFiles.length !== nextFiles.length ||
+        currentFiles.some((file, idx) => file !== nextFiles[idx]);
+    if (!changed) {
+        return;
+    }
+    metadata.files = nextFiles;
+    const headCommitHash = (await git.revparse([branch])).trim();
+    await (0, repo_tools_1.gitWriteNote)(git, headCommitHash, metadata, gitConf.gitNotes.namespace);
+}
 async function gitPRUpdateComments(git, branch, details, config) {
     const gitConf = (0, repo_tools_1.gitLoad)(config);
     const metadata = await gitGetPRMetadata(git, branch, config);