agentic-api 2.0.314 → 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)
@@ -231,31 +238,40 @@ class RAGManager {
      */
     notifyUpdate(name, opts) {
         const embeddingData = this.loadedEmbeddings.get(name);
+        console.log(`\n🔔 notifyUpdate('${name}') appelé`);
+        console.log(`   Embedding en cache: ${embeddingData ? 'OUI' : 'NON'}`);
+        // Si l'embedding n'est pas encore chargé, rien à faire
+        // Il sera chargé avec la nouvelle config au prochain load()
         if (!embeddingData) {
-            if (this.config.verbose)
-                console.log(`ℹ️ Aucun embedding chargé pour '${name}'`);
+            console.log(`   ⏭️  Skip: sera chargé avec la nouvelle config au prochain load()`);
             return;
         }
+        // Charger la nouvelle configuration depuis le registre
+        const entry = this.getEntry(name);
+        if (!entry) {
+            console.log(`   ⚠️  Entry '${name}' introuvable dans le registre`);
+            return;
+        }
+        console.log(`   📁 entry.configPath: ${entry.configPath}`);
+        // L'embedding est chargé, forcer son rechargement via update()
+        // update() modifie l'instance EN PLACE, donc tous ceux qui ont une référence voient la nouvelle version
         const { embedding } = embeddingData;
         try {
-            // Charger la nouvelle configuration
-            const entry = this.getEntry(name);
-            if (!entry) {
-                throw new Error(`RAG '${name}' n'existe plus dans le registre`);
-            }
             const newConfig = this.loadConfig(entry.configPath);
+            console.log(`   🔄 Appel de embedding.update() avec baseDir: ${newConfig.baseDir}`);
             // FIXME: Vérifier si l'embedding est busy avant de faire l'update
-            // Pour l'instant, on appelle update() directement
+            // update() va recharger l'index, les métadonnées et le mapping depuis newConfig.baseDir
+            // update() modifie l'instance en place, donc tous les utilisateurs voient la nouvelle version
             embedding.update(newConfig);
-            if (this.config.verbose) {
-                const action = opts?.action === 'rename'
-                    ? `rename ${opts.oldFile} → ${opts.newFile}`
-                    : 'rebuild';
-                console.log(`✅ Embedding '${name}' notifié de la mise à jour (${action})`);
-            }
+            // Mettre à jour le timestamp du cache
+            embeddingData.loadTime = Date.now();
+            console.log(`   ✅ Embedding rechargé avec succès`);
+            console.log(`   ✅ embedding.isReady(): ${embedding.isReady()}`);
         }
         catch (error) {
-            console.error(`❌ Erreur lors de la notification d'update pour '${name}':`, error);
+            console.error(`   ❌ Erreur lors de la mise à jour de l'embedding '${name}':`, error);
+            // En cas d'erreur, update() a déjà fait un rollback de sa propre config
+            // L'instance continue de fonctionner avec l'ancienne config
             // Ne pas throw pour éviter de bloquer le flow
         }
     }
@@ -486,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');
     }
@@ -677,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
      *
@@ -777,6 +872,9 @@ class RAGManager {
             this.cachedRegistry = { ...registry };
             this.saveRegistry(registry);
             console.log(`✅ RAG '${name}' construit avec succès`);
+            console.log(`   📁 configPath final: ${entry.configPath}`);
+            console.log(`   📦 Embeddings chargés en cache: ${this.loadedEmbeddings.size}`);
+            console.log(`   🔍 Embedding '${name}' dans le cache: ${this.loadedEmbeddings.has(name) ? 'OUI' : 'NON'}`);
             // Notifier les embeddings chargés de se mettre à jour
             this.notifyUpdate(name);
         }
@@ -869,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
@@ -1029,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
@@ -1039,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) {
@@ -1061,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
             };
@@ -1088,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.e2e.helper.js

@@ -82,15 +82,34 @@ class GitE2EHelper {
             await fs_1.promises.mkdir(uploadDir, { recursive: true });
             // Initialiser le repository Git
             await this.git.init();
+            // FIXME: remove this hack that wait for the .git directory to be created
+            // ✅ Attendre que le répertoire .git soit complètement créé
+            const gitDir = (0, path_1.join)(this.tempRepoPath, '.git');
+            // let attempts = 0;
+            // while (!existsSync(gitDir) && attempts < 50) {
+            //   await new Promise(resolve => setTimeout(resolve, 10));
+            //   attempts++;
+            // }
+            if (!(0, fs_1.existsSync)(gitDir)) {
+                throw new Error('.git directory not created after 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
+            // Créer un commit initial avec un README.md valide (avec front-matter pour les tests withID)
             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.');
+            const readmeContent = `---
+id: 1000
+title: E2E Test Repository
+---
+
+# E2E Test Repository
+
+Temporary repository for E2E testing.`;
+            await fs_1.promises.writeFile(readmePath, readmeContent);
             await this.git.add('README.md');
             await this.git.commit('Initial commit');
             // Créer la branche draft à partir de main

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

@@ -1,4 +1,4 @@
-import { RulesGitConfig, GitHealthStatus } from '../types';
+import { RulesGitConfig, GitHealthStatus, GitPrNoteMigrationReport } from '../types';
 /**
  * Rapport d'analyse des IDs
  */
@@ -73,8 +73,10 @@ export declare class GitHealthManager {
      * - 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
+     *
+     * @returns GitPrNoteMigrationReport avec le nombre de notes migrées, déjà OK, et perdues
      */
-    migrateNotes(): Promise<void>;
+    migrateNotes(): Promise<GitPrNoteMigrationReport>;
     /**
      * Analyse les IDs des documents Markdown dans une branche
      *

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

@@ -31,8 +31,7 @@ class GitHealthManager {
             await this.git.checkout(branch);
         }
         catch (checkoutError) {
-            // Si checkout normal échoue, forcer le checkout
-            console.log(`🔧 Checkout forcé vers ${branch}...`, checkoutError);
+            // Si checkout normal échoue, continuer (forceRepair gérera l'erreur)
         }
         try {
             // Use the robust health diagnostic function
@@ -142,12 +141,14 @@ class GitHealthManager {
             const draftHealth = await (0, git_1.gitGetBranchHealth)(this.git, draftBranch);
             results.push(draftHealth);
             this.displayHealthSummary(draftHealth);
-            // Check all validation branches
+            // Check all validation branches with optimized function
             const allBranches = await (0, git_1.gitGetAllBranches)(this.git);
             const validationBranches = allBranches.filter(b => b.startsWith(validationPrefix));
             if (validationBranches.length > 0) {
+                console.log(`🔍 Diagnostic optimisé de ${validationBranches.length} branche(s) de validation...`);
                 for (const branch of validationBranches) {
-                    const health = await (0, git_1.gitGetBranchHealth)(this.git, branch);
+                    // ✅ OPTIMISATION: Utiliser la version légère pour les validations
+                    const health = await (0, git_1.gitGetValidationBranchHealth)(this.git, branch, this.config);
                     results.push(health);
                     this.displayHealthSummary(health);
                 }
@@ -294,20 +295,23 @@ class GitHealthManager {
      * - 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
+     *
+     * @returns GitPrNoteMigrationReport avec le nombre de notes migrées, déjà OK, et perdues
      */
     async migrateNotes() {
         const { mainBranch, validationPrefix, gitNotes } = this.config;
         if (!validationPrefix || !gitNotes.namespace) {
             console.error("Erreur: Le préfixe de validation ou le namespace des notes n'est pas configuré.");
-            return;
+            return { migrated: 0, alreadyOk: 0, lost: [] };
         }
         const allBranches = await (0, git_1.gitGetAllBranches)(this.git);
         const validationBranches = allBranches.filter(b => b.startsWith(validationPrefix));
         if (validationBranches.length === 0) {
-            return;
+            return { migrated: 0, alreadyOk: 0, lost: [] };
         }
         let migratedCount = 0;
         let alreadyOkCount = 0;
+        const lostNotes = [];
         for (const branch of validationBranches) {
             try {
                 const lastCommit = (await this.git.revparse(branch)).trim();
@@ -325,12 +329,20 @@ class GitHealthManager {
                 }
                 const revListOutput = await this.git.raw('rev-list', `${mergeBase}..${branch}`);
                 const branchCommits = revListOutput.split('\n').filter(Boolean);
+                // Extract PR number from branch name (e.g., rule-validation-31 -> 31)
+                const prNumber = parseInt(branch.split('-').pop() || '0', 10);
                 let oldNoteCommit = null;
                 for (const commitHash of branchCommits) {
                     const note = await (0, git_1.gitReadNote)(this.git, commitHash, gitNotes.namespace, 1);
                     if (note) {
-                        oldNoteCommit = commitHash;
-                        break; // Found the first note, stop searching
+                        // CRITICAL FIX: Verify the note belongs to this PR before migrating
+                        if (note.id === prNumber) {
+                            oldNoteCommit = commitHash;
+                            break; // Found the correct note for this PR
+                        }
+                        else {
+                            console.log(`   ⚠️  ${branch}: Note trouvée avec ID=${note.id}, attendu ID=${prNumber} - ignorée`);
+                        }
                     }
                 }
                 // 3. If a note was found on an old commit, migrate it
@@ -341,6 +353,11 @@ class GitHealthManager {
                     console.log(`✅ ${branch}: Migration terminée`);
                     migratedCount++;
                 }
+                else {
+                    // CRITICAL: Note perdue pour cette validation
+                    console.error(`🚨 ${branch}: NOTE PERDUE - PR ${prNumber} n'a plus de note dans son historique`);
+                    lostNotes.push({ branch, prNumber });
+                }
             }
             catch (error) {
                 console.error(`❌ ${branch}: Erreur lors de la migration:`, error);
@@ -348,9 +365,14 @@ class GitHealthManager {
             }
         }
         // Summary only if there was work to do
-        if (migratedCount > 0 || alreadyOkCount !== validationBranches.length) {
-            console.log(`✅ Migration des notes terminée: ${migratedCount} migrées, ${alreadyOkCount} déjà OK`);
+        if (migratedCount > 0 || alreadyOkCount !== validationBranches.length || lostNotes.length > 0) {
+            console.log(`✅ Migration des notes terminée: ${migratedCount} migrées, ${alreadyOkCount} déjà OK${lostNotes.length > 0 ? `, ${lostNotes.length} perdues 🚨` : ''}`);
         }
+        return {
+            migrated: migratedCount,
+            alreadyOk: alreadyOkCount,
+            lost: lostNotes
+        };
     }
     /**
      * Analyse les IDs des documents Markdown dans une branche
@@ -428,9 +450,9 @@ class GitHealthManager {
                             else {
                                 hasValidID = true;
                                 // Enregistrer l'ID existant dans le registry
-                                // ✅ Passer branch et file pour vérifier si l'ID appartient au même fichier
+                                // ✅ gitRegisterExistingID() appelle maintenant setMatterCache() automatiquement si matter est fourni
                                 try {
-                                    (0, git_1.gitRegisterExistingID)(matter.id, branchName, file, this.config);
+                                    (0, git_1.gitRegisterExistingID)(matter, branchName, file, this.config);
                                 }
                                 catch (error) {
                                     if (error.code === 'id_already_used') {
@@ -529,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)) {
@@ -548,11 +608,44 @@ 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
-                    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)
+                        const titleMatch = content.match(/^#\s+(.+)$/m);
+                        if (titleMatch) {
+                            fullMatter.title = titleMatch[1].trim();
+                        }
+                        else {
+                            // Sinon, utiliser le nom du fichier sans extension
+                            const fileName = file.replace(/\.md$/, '').replace(/[-_]/g, ' ');
+                            fullMatter.title = fileName.split(' ').map(w => w.charAt(0).toUpperCase() + w.slice(1)).join(' ');
+                        }
+                        console.log(`   🔧 ${file}: Génération d'un titre: ${fullMatter.title}`);
+                    }
                     // 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 });
@@ -618,6 +711,10 @@ class GitHealthManager {
         if (autoFix && (report.missingID.length > 0 || report.missingTitle.length > 0 || report.invalidID.length > 0 || report.duplicateID.length > 0)) {
             finalReport = await this.repairSafeIDs(report, { dryRun });
         }
+        // Calculer le nombre de fichiers réparés
+        // C'est la différence entre les problèmes avant et après réparation
+        const fixed = (report.missingID.length + report.missingTitle.length + report.invalidID.length + report.duplicateID.length) -
+            (finalReport.missingID.length + finalReport.missingTitle.length + finalReport.invalidID.length + finalReport.duplicateID.length);
         // Retourner dans l'ancien format pour compatibilité
         return {
             scanned: finalReport.scanned,
@@ -626,7 +723,7 @@ class GitHealthManager {
             missingTitle: finalReport.missingTitle.length,
             invalidID: finalReport.invalidID.length,
             duplicateID: finalReport.duplicateID.length,
-            fixed: report.scanned - finalReport.scanned + finalReport.valid - report.valid,
+            fixed: Math.max(0, fixed), // S'assurer que fixed n'est pas négatif
             errors: finalReport.errors
         };
     }

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

@@ -1,5 +1,5 @@
 export { lock, unlock, gitLoad, isValidInt, gitIsFileMerged, gitLastCommit, gitListFilesInBranch, gitListFilesOutsideRepo, gitFileExistsInBranch, gitGetFilesSummary, gitGetFileContent, gitGetFilePreview, gitGetFileHistory, gitReadFileOutsideRepo, gitGetUnmergedBranchesForFile, gitGetAllBranches, gitGetDiffFiles, gitReadNote, gitWriteNote, gitDeleteNote, } from './repo.tools';
-export { gitInit, gitEnsureRepositoryConfiguration, gitEnsureRemoteConfiguration, gitSetupRepository, gitShowConfiguration, gitCheckConfiguration, gitGetBranchHealth, gitCreateOrEditFile, gitEditFile, gitRenameFile, gitDeleteFile, gitGenerateNextID, gitReloadIDRegistry, gitRegisterExistingID, gitEnsureMatterID, gitFileStrictMatter, gitIDRegistryExists, gitIDRegistryRename, } from './repo';
+export { gitInit, gitEnsureRepositoryConfiguration, gitEnsureRemoteConfiguration, gitSetupRepository, gitShowConfiguration, gitCheckConfiguration, gitGetBranchHealth, gitGetValidationBranchHealth, gitCreateOrEditFile, gitEditFile, gitRenameFile, gitDeleteFile, gitGenerateNextID, gitReloadIDRegistry, gitRegisterExistingID, gitEnsureMatterID, gitFileStrictMatter, gitIDRegistryExists, gitIDRegistryRename, } from './repo';
 export { gitSyncPR, gitIsPRClosed, gitIsPRClosedRobust, gitGetPRMetadata, gitGetAllPR, gitGetClosedPRs, gitLoadPR, gitPRUpdateComments, gitClosePR, gitClosePRRobust, gitGetNextPRNumber, gitNewValidationRequest, gitNewPR, } from './repo.pr';
 export * from './git.e2e.helper';
 export * from './git.health';