agentic-api 2.0.31 → 2.0.314

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
  *
@@ -173,7 +175,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 ? '...' : ''}`);
@@ -350,5 +352,283 @@ class GitHealthManager {
             console.log(`✅ Migration des notes terminée: ${migratedCount} migrées, ${alreadyOkCount} déjà OK`);
         }
     }
+    /**
+     * 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
+                                // ✅ Passer branch et file pour vérifier si l'ID appartient au même fichier
+                                try {
+                                    (0, git_1.gitRegisterExistingID)(matter.id, 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
+                    fullMatter.id = (0, git_1.gitGenerateNextID)(this.config);
+                    console.log(`   🔧 ${file}: Génération d'un nouvel ID: ${fullMatter.id}`);
+                    // 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 });
+        }
+        // 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: report.scanned - finalReport.scanned + finalReport.valid - report.valid,
+            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, 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.gitNewValidationRequest = 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.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 = 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; } });
@@ -54,6 +57,14 @@ Object.defineProperty(exports, "gitCreateOrEditFile", { enumerable: true, get: f
 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,122 @@
 import { SimpleGit } from 'simple-git';
 import { RulesGitConfig, GitCommitHistory, RuleUser, GitHealthStatus } from '../types';
+/**
+ * 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 id 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).
+ */
+export declare function gitRegisterExistingID(id: number, 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
+ * @param matter Le matter à valider/compléter
+ * @param config Configuration Git optionnelle
+ * @returns Le matter mis à jour avec un ID valide
+ */
+export declare function gitEnsureMatterID(matter: any, config?: RulesGitConfig): 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