agentic-api 2.0.31 → 2.0.491

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

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GitHealthManager = void 0;
 const git_1 = require("../git");
+const utils_matter_1 = require("../utils.matter");
+const repo_1 = require("./repo");
 /**
  * Git Repository Health Manager
  *
@@ -29,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
@@ -140,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);
                 }
@@ -173,7 +176,7 @@ class GitHealthManager {
      */
     displayHealthSummary(health) {
         if (health.healthy) {
-            console.log(`✅ ${health.branch}`);
+            //console.log(`✅ ${health.branch}`);
         }
         else {
             console.log(`⚠️  ${health.branch}: ${health.issues.slice(0, 2).join(', ')}${health.issues.length > 2 ? '...' : ''}`);
@@ -292,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();
@@ -323,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
@@ -339,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);
@@ -346,9 +365,312 @@ 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
+     *
+     * @param branch Branche à analyser (par défaut: toutes les branches)
+     * @returns Rapport d'analyse avec les fichiers problématiques
+     */
+    async analyseSafeIDs(branch) {
+        const isValidInteger = (value) => {
+            return typeof value === 'number' && value > 0 && value % 1 === 0;
+        };
+        // Vérifier si la validation des IDs est activée
+        if (!this.config.withID) {
+            console.log('ℹ️  La validation des IDs est désactivée (withID: false)');
+            return {
+                scanned: 0,
+                valid: 0,
+                missingID: [],
+                missingTitle: [],
+                invalidID: [],
+                duplicateID: [],
+                errors: []
+            };
+        }
+        console.log(`🔍 Analyse des documents Markdown pour validation des IDs...`);
+        // 
+        // First time we check if the ID registry exists, and force the strictID mode
+        this.config.strictID = !(0, repo_1.gitIDRegistryExists)(this.config) || this.config.strictID;
+        if (this.config.strictID) {
+            console.log(`   Mode strict activé: documents sans ID seront rejetés`);
+        }
+        const report = {
+            scanned: 0,
+            valid: 0,
+            missingID: [],
+            missingTitle: [],
+            invalidID: [],
+            duplicateID: [],
+            errors: []
+        };
+        try {
+            // Déterminer les branches à scanner
+            const branchesToScan = branch
+                ? [branch]
+                : await (0, git_1.gitGetAllBranches)(this.git);
+            console.log(`📂 Branches à scanner: ${branchesToScan.length} (${branchesToScan.join(', ')})`);
+            for (const branchName of branchesToScan) {
+                try {
+                    // Lister tous les fichiers .md dans la branche
+                    const allFiles = await (0, git_1.gitListFilesInBranch)(this.git, branchName);
+                    const mdFiles = allFiles.filter(f => f.endsWith('.md'));
+                    // Variables pour suivre les problèmes dans cette branche
+                    let branchHasIssues = false;
+                    const branchIssues = [];
+                    for (const file of mdFiles) {
+                        report.scanned++;
+                        try {
+                            // ✅ OPTIMISATION: Lecture rapide du matter (id + title uniquement)
+                            // Utilise le cache, évite de parser tout le fichier
+                            const matter = await (0, git_1.gitFileStrictMatter)(this.git, file, branchName, this.config);
+                            // Vérification de l'ID et du titre
+                            let hasValidID = false;
+                            let hasValidTitle = false;
+                            const fileRef = `${branchName}:${file}`;
+                            if (!isValidInteger(matter.id)) {
+                                report.missingID.push(fileRef);
+                                branchHasIssues = true;
+                                branchIssues.push(`   ⚠️  ${file}: ID manquant`);
+                            }
+                            else if (matter.id <= 999) {
+                                report.invalidID.push(`${fileRef} (id=${matter.id})`);
+                                branchHasIssues = true;
+                                branchIssues.push(`   ⚠️  ${file}: ID invalide (${matter.id} <= 999)`);
+                            }
+                            else {
+                                hasValidID = true;
+                                // Enregistrer l'ID existant dans le registry
+                                // ✅ gitRegisterExistingID() appelle maintenant setMatterCache() automatiquement si matter est fourni
+                                try {
+                                    (0, git_1.gitRegisterExistingID)(matter, branchName, file, this.config);
+                                }
+                                catch (error) {
+                                    if (error.code === 'id_already_used') {
+                                        // Compter les doublons mais ne pas les ajouter aux erreurs (seront réparés)
+                                        report.duplicateID.push(`${fileRef} (id=${matter.id})`);
+                                        hasValidID = false;
+                                        branchHasIssues = true;
+                                        branchIssues.push(`   ⚠️  ${file}: ID ${matter.id} déjà utilisé`);
+                                    }
+                                }
+                            }
+                            // Vérification du titre
+                            if (!matter.title || matter.title.trim() === '') {
+                                report.missingTitle.push(fileRef);
+                                branchHasIssues = true;
+                                branchIssues.push(`   ⚠️  ${file}: Titre manquant`);
+                            }
+                            else {
+                                hasValidTitle = true;
+                            }
+                            // Si le document est valide (ID + titre)
+                            if (hasValidID && hasValidTitle) {
+                                report.valid++;
+                            }
+                            // Mode strict sans auto-fix : rejeter
+                            if (!hasValidID && this.config.strictID) {
+                                report.errors.push(`${fileRef} - Document rejeté (strictID: true, ID invalide)`);
+                                branchIssues.push(`   ❌ ${file}: REJETÉ (mode strict)`);
+                            }
+                        }
+                        catch (parseError) {
+                            const fileRef = `${branchName}:${file}`;
+                            report.errors.push(`${fileRef} - Erreur de parsing: ${parseError.message}`);
+                            branchIssues.push(`   ❌ ${file}: Erreur de parsing: ${parseError.message}`);
+                            branchHasIssues = true;
+                        }
+                    }
+                    // Afficher les problèmes de la branche seulement s'il y en a
+                    if (branchHasIssues) {
+                        console.log(`\n📂 Scan de la branche: ${branchName} (${mdFiles.length} fichiers)`);
+                        branchIssues.forEach(issue => console.log(issue));
+                    }
+                }
+                catch (branchError) {
+                    report.errors.push(`${branchName} - Erreur lors du scan: ${branchError.message}`);
+                    console.error(`   ❌ Erreur lors du scan de ${branchName}:`, branchError.message);
+                }
+            }
+            // Résumé
+            console.log(`\n📊 Résumé de l'analyse:`);
+            console.log(`   Documents scannés: ${report.scanned}`);
+            console.log(`   ✅ Valides: ${report.valid}`);
+            if (report.missingID.length > 0)
+                console.log(`   ⚠️  IDs manquants: ${report.missingID.length}`);
+            if (report.missingTitle.length > 0)
+                console.log(`   ⚠️  Titres manquants: ${report.missingTitle.length}`);
+            if (report.invalidID.length > 0)
+                console.log(`   ⚠️  IDs invalides: ${report.invalidID.length}`);
+            if (report.duplicateID.length > 0)
+                console.log(`   ⚠️  IDs en doublon: ${report.duplicateID.length}`);
+            if (report.errors.length > 0)
+                console.log(`   ❌ Erreurs: ${report.errors.length}`);
+            return report;
+        }
+        catch (error) {
+            console.error('❌ Erreur lors de l\'analyse des documents:', error);
+            throw error;
+        }
+    }
+    /**
+     * Répare les IDs problématiques identifiés dans un rapport d'analyse
+     *
+     * @param report Rapport d'analyse généré par analyseSafeIDs
+     * @param options Options de réparation
+     * @param options.dryRun Mode simulation (affiche les réparations sans modifier)
+     * @returns Rapport mis à jour avec les fichiers réparés
+     */
+    async repairSafeIDs(report, options = {}) {
+        const { dryRun = false } = options;
+        console.log(`\n🔧 ${dryRun ? 'SIMULATION' : 'RÉPARATION'} des IDs problématiques...`);
+        const updatedReport = {
+            scanned: report.scanned,
+            valid: report.valid,
+            missingID: [...report.missingID],
+            missingTitle: [...report.missingTitle],
+            invalidID: [...report.invalidID],
+            duplicateID: [...report.duplicateID],
+            errors: [...report.errors]
+        };
+        // Collecter tous les fichiers à réparer
+        const filesToFix = [
+            ...report.missingID,
+            ...report.missingTitle,
+            ...report.invalidID.map(e => e.split(' (id=')[0]),
+            ...report.duplicateID.map(e => e.split(' (id=')[0])
+        ];
+        let fixed = 0;
+        const fixedFiles = new Set();
+        for (const fileRef of filesToFix) {
+            // Éviter de réparer deux fois le même fichier
+            if (fixedFiles.has(fileRef)) {
+                continue;
+            }
+            const [branchName, ...fileParts] = fileRef.split(':');
+            const file = fileParts.join(':');
+            try {
+                if (!dryRun) {
+                    // Lire le contenu complet pour réparer
+                    const fileData = await (0, git_1.gitGetFileContent)(this.git, file, branchName);
+                    if (!fileData || !fileData.content) {
+                        updatedReport.errors.push(`${fileRef} - Fichier inaccessible pour réparation`);
+                        console.log(`   ❌ ${file}: Fichier inaccessible`);
+                        continue;
+                    }
+                    // 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}`);
+                    }
+                    // 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);
+                    // ✅ 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 });
+                    fixed++;
+                    fixedFiles.add(fileRef);
+                    console.log(`   ✅ ${file}: Réparé avec ID ${fullMatter.id}`);
+                    // Retirer des listes de problèmes
+                    updatedReport.missingID = updatedReport.missingID.filter(f => f !== fileRef);
+                    updatedReport.missingTitle = updatedReport.missingTitle.filter(f => f !== fileRef);
+                    updatedReport.invalidID = updatedReport.invalidID.filter(f => !f.startsWith(fileRef));
+                    updatedReport.duplicateID = updatedReport.duplicateID.filter(f => !f.startsWith(fileRef));
+                    updatedReport.valid++;
+                }
+                else {
+                    // Mode simulation
+                    console.log(`   🔍 ${file}: Nécessite réparation (simulation)`);
+                    fixed++;
+                }
+            }
+            catch (fixError) {
+                updatedReport.errors.push(`${fileRef} - Erreur de réparation: ${fixError.message}`);
+                console.log(`   ❌ ${file}: Erreur de réparation: ${fixError.message}`);
+            }
+        }
+        // Résumé
+        console.log(`\n📊 Résumé de la réparation:`);
+        console.log(`   ${dryRun ? 'Fichiers à réparer' : 'Fichiers réparés'}: ${fixed}`);
+        if (!dryRun) {
+            console.log(`   ✅ Valides après réparation: ${updatedReport.valid}`);
+            if (updatedReport.missingID.length > 0)
+                console.log(`   ⚠️  IDs manquants restants: ${updatedReport.missingID.length}`);
+            if (updatedReport.missingTitle.length > 0)
+                console.log(`   ⚠️  Titres manquants restants: ${updatedReport.missingTitle.length}`);
+            if (updatedReport.invalidID.length > 0)
+                console.log(`   ⚠️  IDs invalides restants: ${updatedReport.invalidID.length}`);
+            if (updatedReport.duplicateID.length > 0)
+                console.log(`   ⚠️  IDs en doublon restants: ${updatedReport.duplicateID.length}`);
+        }
+        else {
+            console.log(`\nℹ️  Mode simulation: Utilisez { dryRun: false } pour réparer effectivement`);
+        }
+        return updatedReport;
+    }
+    /**
+     * Vérifie et répare les IDs manquants dans tous les documents Markdown du repository
+     *
+     * Cette méthode orchestre l'analyse et la réparation :
+     * 1. Analyse les documents avec analyseSafeIDs()
+     * 2. Si autoFix est activé, répare avec repairSafeIDs()
+     *
+     * @param options Options de scan et réparation
+     * @param options.branch Branche spécifique à scanner (par défaut: toutes les branches)
+     * @param options.autoFix Active la réparation automatique (par défaut: false)
+     * @param options.dryRun Mode simulation (affiche les problèmes sans modifier)
+     * @returns Résumé des documents scannés et réparés
+     */
+    async ensureSafeIDS(options = {}) {
+        const { branch, autoFix = false, dryRun = false } = options;
+        // Étape 1: Analyser
+        const report = await this.analyseSafeIDs(branch);
+        let finalReport = report;
+        // Étape 2: Réparer si demandé
+        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,
+            valid: finalReport.valid,
+            missingID: finalReport.missingID.length,
+            missingTitle: finalReport.missingTitle.length,
+            invalidID: finalReport.invalidID.length,
+            duplicateID: finalReport.duplicateID.length,
+            fixed: Math.max(0, fixed), // S'assurer que fixed n'est pas négatif
+            errors: finalReport.errors
+        };
     }
 }
 exports.GitHealthManager = GitHealthManager;

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

@@ -1,5 +1,5 @@
-export { lock, unlock, gitLoad, 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, } from './repo';
+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, 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';

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

@@ -14,7 +14,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.gitNewPR = exports.gitNewValidationRequest = exports.gitGetNextPRNumber = exports.gitClosePRRobust = exports.gitClosePR = exports.gitPRUpdateComments = exports.gitLoadPR = exports.gitGetClosedPRs = exports.gitGetAllPR = exports.gitGetPRMetadata = exports.gitIsPRClosedRobust = exports.gitIsPRClosed = exports.gitSyncPR = exports.gitDeleteFile = exports.gitRenameFile = exports.gitEditFile = exports.gitCreateOrEditFile = exports.gitGetBranchHealth = exports.gitCheckConfiguration = exports.gitShowConfiguration = exports.gitSetupRepository = exports.gitEnsureRemoteConfiguration = exports.gitEnsureRepositoryConfiguration = exports.gitInit = exports.gitDeleteNote = exports.gitWriteNote = exports.gitReadNote = exports.gitGetDiffFiles = exports.gitGetAllBranches = exports.gitGetUnmergedBranchesForFile = exports.gitReadFileOutsideRepo = exports.gitGetFileHistory = exports.gitGetFilePreview = exports.gitGetFileContent = exports.gitGetFilesSummary = exports.gitFileExistsInBranch = exports.gitListFilesOutsideRepo = exports.gitListFilesInBranch = exports.gitLastCommit = exports.gitIsFileMerged = exports.gitLoad = exports.unlock = exports.lock = void 0;
+exports.gitGetNextPRNumber = exports.gitClosePRRobust = exports.gitClosePR = exports.gitPRUpdateComments = exports.gitLoadPR = exports.gitGetClosedPRs = exports.gitGetAllPR = exports.gitGetPRMetadata = exports.gitIsPRClosedRobust = exports.gitIsPRClosed = exports.gitSyncPR = exports.gitIDRegistryRename = exports.gitIDRegistryExists = exports.gitFileStrictMatter = exports.gitEnsureMatterID = exports.gitRegisterExistingID = exports.gitReloadIDRegistry = exports.gitGenerateNextID = exports.gitDeleteFile = exports.gitRenameFile = exports.gitEditFile = exports.gitCreateOrEditFile = exports.gitGetValidationBranchHealth = exports.gitGetBranchHealth = exports.gitCheckConfiguration = exports.gitShowConfiguration = exports.gitSetupRepository = exports.gitEnsureRemoteConfiguration = exports.gitEnsureRepositoryConfiguration = exports.gitInit = exports.gitDeleteNote = exports.gitWriteNote = exports.gitReadNote = exports.gitGetDiffFiles = exports.gitGetAllBranches = exports.gitGetUnmergedBranchesForFile = exports.gitReadFileOutsideRepo = exports.gitGetFileHistory = exports.gitGetFilePreview = exports.gitGetFileContent = exports.gitGetFilesSummary = exports.gitFileExistsInBranch = exports.gitListFilesOutsideRepo = exports.gitListFilesInBranch = exports.gitLastCommit = exports.gitIsFileMerged = exports.isValidInt = exports.gitLoad = exports.unlock = exports.lock = void 0;
+exports.gitNewPR = exports.gitNewValidationRequest = void 0;
 // === OPÉRATIONS GIT BAS NIVEAU ===
 // Fonctions atomiques pour manipuler Git directement
 var repo_tools_1 = require("./repo.tools");
@@ -23,6 +24,8 @@ Object.defineProperty(exports, "lock", { enumerable: true, get: function () { re
 Object.defineProperty(exports, "unlock", { enumerable: true, get: function () { return repo_tools_1.unlock; } });
 // Configuration
 Object.defineProperty(exports, "gitLoad", { enumerable: true, get: function () { return repo_tools_1.gitLoad; } });
+// Validation
+Object.defineProperty(exports, "isValidInt", { enumerable: true, get: function () { return repo_tools_1.isValidInt; } });
 // Lecture de fichiers
 Object.defineProperty(exports, "gitIsFileMerged", { enumerable: true, get: function () { return repo_tools_1.gitIsFileMerged; } });
 Object.defineProperty(exports, "gitLastCommit", { enumerable: true, get: function () { return repo_tools_1.gitLastCommit; } });
@@ -50,10 +53,19 @@ Object.defineProperty(exports, "gitSetupRepository", { enumerable: true, get: fu
 Object.defineProperty(exports, "gitShowConfiguration", { enumerable: true, get: function () { return repo_1.gitShowConfiguration; } });
 Object.defineProperty(exports, "gitCheckConfiguration", { enumerable: true, get: function () { return repo_1.gitCheckConfiguration; } });
 Object.defineProperty(exports, "gitGetBranchHealth", { enumerable: true, get: function () { return repo_1.gitGetBranchHealth; } });
+Object.defineProperty(exports, "gitGetValidationBranchHealth", { enumerable: true, get: function () { return repo_1.gitGetValidationBranchHealth; } });
 Object.defineProperty(exports, "gitCreateOrEditFile", { enumerable: true, get: function () { return repo_1.gitCreateOrEditFile; } });
 Object.defineProperty(exports, "gitEditFile", { enumerable: true, get: function () { return repo_1.gitEditFile; } });
 Object.defineProperty(exports, "gitRenameFile", { enumerable: true, get: function () { return repo_1.gitRenameFile; } });
 Object.defineProperty(exports, "gitDeleteFile", { enumerable: true, get: function () { return repo_1.gitDeleteFile; } });
+// ID Management & Matter Cache
+Object.defineProperty(exports, "gitGenerateNextID", { enumerable: true, get: function () { return repo_1.gitGenerateNextID; } });
+Object.defineProperty(exports, "gitReloadIDRegistry", { enumerable: true, get: function () { return repo_1.gitReloadIDRegistry; } });
+Object.defineProperty(exports, "gitRegisterExistingID", { enumerable: true, get: function () { return repo_1.gitRegisterExistingID; } });
+Object.defineProperty(exports, "gitEnsureMatterID", { enumerable: true, get: function () { return repo_1.gitEnsureMatterID; } });
+Object.defineProperty(exports, "gitFileStrictMatter", { enumerable: true, get: function () { return repo_1.gitFileStrictMatter; } });
+Object.defineProperty(exports, "gitIDRegistryExists", { enumerable: true, get: function () { return repo_1.gitIDRegistryExists; } });
+Object.defineProperty(exports, "gitIDRegistryRename", { enumerable: true, get: function () { return repo_1.gitIDRegistryRename; } });
 // === GESTION DES PULL REQUESTS (repo.pr.ts) ===
 var repo_pr_1 = require("./repo.pr");
 // Synchronisation et statut

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

@@ -1,5 +1,141 @@
 import { SimpleGit } from 'simple-git';
 import { RulesGitConfig, GitCommitHistory, RuleUser, GitHealthStatus } from '../types';
+/**
+ * Structure du cache matter pour un fichier
+ */
+interface MatterStrict {
+    id?: number;
+    title?: string;
+    service?: string;
+    oldfile?: string;
+}
+/**
+ * Vérifie si le fichier de registre d'IDs existe dans le repository Git
+ *
+ * Cette fonction est utile pour détecter si le système d'ID natif a été initialisé
+ * dans le repository. Le fichier `with-ids.json` est créé automatiquement lors du
+ * premier appel à `gitGenerateNextID()` ou `gitEnsureMatterID()`.
+ *
+ * @param config Configuration Git optionnelle (utilise la config par défaut si non fournie)
+ * @returns `true` si le fichier `.git/with-ids.json` existe, `false` sinon
+ *
+ * @example
+ * ```typescript
+ * const config = gitLoad({ repoPath: './my-repo' });
+ *
+ * if (gitIDRegistryExists(config)) {
+ *   console.log('Le registre d\'IDs existe déjà');
+ *   // On peut charger le registre existant
+ *   gitReloadIDRegistry(config);
+ * } else {
+ *   console.log('Première utilisation du système d\'IDs');
+ *   // Le registre sera créé au premier gitGenerateNextID()
+ * }
+ * ```
+ */
+export declare function gitIDRegistryExists(config?: RulesGitConfig): boolean;
+/**
+ * Génère un nouvel ID unique en incrémentant de +20
+ * @param config Configuration Git optionnelle
+ * @returns Un nouvel ID unique
+ */
+export declare function gitGenerateNextID(config?: RulesGitConfig): number;
+/**
+ * Force le rechargement du registre d'IDs depuis le disque
+ *
+ * **Utilisé principalement pour les tests qui simulent un redémarrage du serveur.**
+ *
+ * En production, cette fonction n'est pas nécessaire car le singleton est
+ * réinitialisé à chaque redémarrage du process Node.js.
+ *
+ * @param config Configuration Git optionnelle
+ *
+ * @example
+ * ```typescript
+ * // Dans un test : simuler un redémarrage
+ * await gitCreateOrEditFile(...); // Modifie le registre
+ * gitReloadIDRegistry(); // Force le rechargement depuis le disque
+ * ```
+ */
+export declare function gitReloadIDRegistry(config?: RulesGitConfig): void;
+/**
+ * Enregistre un ID existant dans le registre
+ *
+ * @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
+ * @throws GitOperationError si l'ID est déjà utilisé par un autre fichier
+ *
+ * **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.
+ */
+export declare function gitRegisterExistingID(matter: MatterStrict, branch?: string, file?: string, config?: RulesGitConfig): void;
+/**
+ * Renomme un fichier dans le cache du registre d'IDs
+ *
+ * Cette fonction met à jour le cache lorsqu'un fichier est renommé:
+ * - Supprime l'entrée avec l'ancien nom
+ * - Crée une nouvelle entrée avec le nouveau nom
+ * - Préserve l'ID et les métadonnées
+ *
+ * @param oldFile Ancien nom du fichier
+ * @param newFile Nouveau nom du fichier
+ * @param branch Branche concernée
+ * @param config Configuration Git optionnelle
+ *
+ * @example
+ * ```typescript
+ * // Après un rename dans Git
+ * gitIDRegistryRename('procedure-old.md', 'procedure-new.md', 'rule-validation-1');
+ * ```
+ */
+export declare function gitIDRegistryRename(oldFile: string, newFile: string, branch: string, config?: RulesGitConfig): void;
+/**
+ * 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
+ */
+export declare function gitEnsureMatterID(matter: MatterStrict, config?: RulesGitConfig, branch?: string, file?: string): any;
+/**
+ * Lecture rapide et stricte du matter d'un fichier (id + title uniquement)
+ *
+ * **Optimisation : Utilise le cache du registre d'IDs pour éviter de lire le fichier.**
+ *
+ * Cette fonction :
+ * 1. Vérifie d'abord le cache dans `.git/with-ids.json`
+ * 2. Si absent ou invalidé, lit le fichier avec regex (pas de parsing complet)
+ * 3. Met à jour le cache automatiquement
+ *
+ * @param git Instance SimpleGit
+ * @param filePath Chemin du fichier
+ * @param branch Nom de la branche
+ * @param config Configuration Git optionnelle
+ * @returns { id, title } ou { id: undefined, title: undefined } si absent
+ *
+ * @example
+ * ```typescript
+ * const matter = await gitFileStrictMatter(git, 'doc.md', 'main');
+ * console.log(matter.id);    // 1234
+ * console.log(matter.title); // "Mon Document"
+ * ```
+ */
+export declare function gitFileStrictMatter(git: SimpleGit, filePath: string, branch: string, config?: RulesGitConfig): Promise<{
+    id?: number;
+    title?: string;
+    oldfile?: string;
+}>;
 /**
  * Vérifie et configure un repository Git existant pour s'assurer qu'il a la configuration requise
  * @param git Instance SimpleGit
@@ -126,3 +262,27 @@ export declare function gitDeleteFile(git: SimpleGit, filePath: string, branch:
  * @returns Promise<GitHealthStatus> Diagnostic complet avec liste des problèmes et recommandations de réparation
  */
 export declare function gitGetBranchHealth(git: SimpleGit, branch?: string): Promise<GitHealthStatus>;
+/**
+ * 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é
+ */
+export declare function gitGetValidationBranchHealth(git: SimpleGit, branch: string, config?: RulesGitConfig): Promise<GitHealthStatus>;
+export {};