agentic-api 2.0.31 → 2.0.491

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

@@ -33,6 +33,13 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.gitIDRegistryExists = gitIDRegistryExists;
+exports.gitGenerateNextID = gitGenerateNextID;
+exports.gitReloadIDRegistry = gitReloadIDRegistry;
+exports.gitRegisterExistingID = gitRegisterExistingID;
+exports.gitIDRegistryRename = gitIDRegistryRename;
+exports.gitEnsureMatterID = gitEnsureMatterID;
+exports.gitFileStrictMatter = gitFileStrictMatter;
 exports.gitEnsureRepositoryConfiguration = gitEnsureRepositoryConfiguration;
 exports.gitEnsureRemoteConfiguration = gitEnsureRemoteConfiguration;
 exports.gitInit = gitInit;
@@ -46,11 +53,628 @@ exports.gitRenameFile_fs = gitRenameFile_fs;
 exports.gitRenameFile = gitRenameFile;
 exports.gitDeleteFile = gitDeleteFile;
 exports.gitGetBranchHealth = gitGetBranchHealth;
+exports.gitGetValidationBranchHealth = gitGetValidationBranchHealth;
 const fs_1 = require("fs");
 const errors_1 = require("../errors");
 const path_1 = require("path");
 const fs = __importStar(require("fs/promises"));
 const repo_tools_1 = require("./repo.tools");
+/**
+ * Service singleton pour gérer le registre d'IDs en mémoire
+ */
+class IDRegistryService {
+    constructor() {
+        this.registry = null;
+        this.repoPath = '';
+        this.isDirty = false;
+    }
+    static get() {
+        return IDRegistryService.instance || (IDRegistryService.instance = new IDRegistryService());
+    }
+    toString() {
+        return JSON.stringify(this.registry, null, 2);
+    }
+    clear() {
+        this.registry = null;
+        this.repoPath = '';
+        this.isDirty = false;
+    }
+    /**
+     * Initialise le service avec le chemin du repository
+     */
+    init(repoPath) {
+        // ✅ BUGFIX: Toujours mettre à jour repoPath même si le registre existe déjà
+        // Car gitReloadIDRegistry peut être appelé avec un nouveau repoPath pour un nouveau test
+        // et le repo précédent peut avoir été nettoyé
+        if (this.repoPath !== repoPath) {
+            this.repoPath = repoPath;
+            // Si le registre existe déjà, le recharger depuis le nouveau chemin
+            if (this.registry) {
+                this.registry = this.loadFromDisk();
+                this.isDirty = false;
+                return;
+            }
+        }
+        // Si le registre n'existe pas encore, le créer
+        if (!this.registry) {
+            this.registry = this.loadFromDisk();
+            this.isDirty = false;
+        }
+    }
+    /**
+     * Force le rechargement du registre depuis le disque
+     * Utilisé principalement pour les tests qui simulent un redémarrage
+     */
+    forceReload() {
+        if (!this.repoPath) {
+            throw new Error('IDRegistryService not initialized. Call init() first.');
+        }
+        this.registry = this.loadFromDisk();
+        this.isDirty = false;
+    }
+    /**
+     * Charge le registre depuis le disque
+     */
+    loadFromDisk() {
+        const registryPath = (0, path_1.join)(this.repoPath, '.git', 'with-ids.json');
+        if (!(0, fs_1.existsSync)(registryPath)) {
+            return {
+                last: 980,
+                used: [],
+                updated: new Date().toISOString(),
+                matters: {}
+            };
+        }
+        try {
+            const data = JSON.parse((0, fs_1.readFileSync)(registryPath, 'utf8'));
+            // Migration : ajouter matters si absent (compatibilité anciens registres)
+            if (!data.matters) {
+                data.matters = {};
+            }
+            return data;
+        }
+        catch (error) {
+            console.warn('⚠️ Registre d\'IDs corrompu, création d\'un nouveau');
+            return {
+                last: 980,
+                used: [],
+                updated: new Date().toISOString(),
+                matters: {}
+            };
+        }
+    }
+    /**
+     * Sauvegarde le registre sur le disque (seulement si modifié)
+     */
+    save() {
+        if (!this.registry || !this.isDirty) {
+            return;
+        }
+        const gitDir = (0, path_1.join)(this.repoPath, '.git');
+        const registryPath = (0, path_1.join)(gitDir, 'with-ids.json');
+        // S'assurer que le répertoire .git existe
+        if (!(0, fs_1.existsSync)(gitDir)) {
+            console.warn(`⚠️ Cannot save ID registry: .git directory not found at ${this.repoPath}`);
+            return; // Ne pas sauvegarder si le repo n'est pas initialisé
+        }
+        try {
+            this.registry.updated = new Date().toISOString();
+            (0, fs_1.writeFileSync)(registryPath, JSON.stringify(this.registry, null, 2), 'utf8');
+            this.isDirty = false;
+        }
+        catch (error) {
+            console.warn(`⚠️ Failed to save ID registry:`, error);
+            // Ne pas propager l'erreur, le registre est une optimisation
+        }
+    }
+    /**
+     * Récupère le registre (lecture seule)
+     */
+    getRegistry() {
+        if (!this.registry) {
+            throw new Error('IDRegistryService not initialized. Call init() first.');
+        }
+        return this.registry;
+    }
+    /**
+     * Génère un nouvel ID unique
+     */
+    generateNextID() {
+        if (!this.registry) {
+            throw new Error('IDRegistryService not initialized. Call init() first.');
+        }
+        const newID = this.registry.last + 20;
+        this.registry.last = newID;
+        this.registry.used.push(newID);
+        this.isDirty = true;
+        return newID;
+    }
+    /**
+     * Obtient l'ID d'un fichier (peu importe la branche)
+     *
+     * Un fichier a UN SEUL ID quelque soit la branche où il se trouve.
+     * Cette fonction cherche le fichier dans toutes les branches du cache.
+     *
+     * @param file Nom du fichier (ex: 'procedure.md')
+     * @returns L'ID du fichier ou undefined si le fichier n'a pas d'ID
+     */
+    getFileID(file) {
+        if (!this.registry) {
+            return undefined;
+        }
+        // Chercher le fichier dans toutes les branches
+        for (const [cacheKey, matter] of Object.entries(this.registry.matters)) {
+            const [, cachedFile] = cacheKey.split(':');
+            if (cachedFile === file) {
+                return matter.id;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Vérifie si un ID appartient déjà à un fichier spécifique
+     *
+     * Un fichier garde son ID peu importe la branche, donc cette fonction
+     * cherche dans toutes les branches pour vérifier la propriété.
+     *
+     * @param id L'ID à vérifier
+     * @param file Nom du fichier
+     * @returns true si ce fichier possède cet ID
+     */
+    isIDOwnedByFile(id, file) {
+        if (!this.registry) {
+            return false;
+        }
+        // Chercher le fichier dans toutes les branches
+        const fileID = this.getFileID(file);
+        return fileID === id;
+    }
+    /**
+     * Trouve quel fichier possède un ID donné
+     *
+     * @param id L'ID à chercher
+     * @returns Le nom du fichier qui possède cet ID, ou undefined
+     */
+    getFileByID(id) {
+        if (!this.registry) {
+            return undefined;
+        }
+        // Chercher l'ID dans le cache
+        for (const [cacheKey, matter] of Object.entries(this.registry.matters)) {
+            if (matter.id === id) {
+                const [, file] = cacheKey.split(':');
+                return file;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Enregistre un ID existant
+     *
+     * @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é)
+     * @throws Error si l'ID est déjà utilisé par un autre fichier
+     */
+    registerExistingID(id, branch, file) {
+        if (!this.registry) {
+            throw new Error('IDRegistryService not initialized. Call init() first.');
+        }
+        // Si l'ID est déjà utilisé
+        if (this.registry.used.includes(id)) {
+            // Vérifier si c'est le même fichier (pas un doublon)
+            // Note: isIDOwnedByFile() cherche maintenant dans TOUTES les branches
+            if (file && this.isIDOwnedByFile(id, file)) {
+                // Même fichier → OK, pas d'erreur
+                return;
+            }
+            // ID utilisé par un autre fichier → Erreur
+            const error = new Error(`ID ${id} est déjà utilisé`);
+            error.code = 'id_already_used';
+            throw error;
+        }
+        // Nouvel ID → Enregistrer
+        this.registry.used.push(id);
+        if (id > this.registry.last) {
+            this.registry.last = id;
+        }
+        // ⚠️ IMPORTANT: Ne PAS créer d'entrée dans matters ici
+        // setMatterCache() DOIT être appelé AVANT registerExistingID() par l'appelant
+        // car registerExistingID() n'a pas le contexte complet (title, service)
+        // Si branch/file sont fournis mais que le cache n'existe pas, c'est une erreur de programmation
+        this.isDirty = true;
+    }
+    /**
+     * Récupère un matter depuis le cache
+     * Note: Le champ 'updated' est filtré pour ne pas être exposé à l'extérieur
+     */
+    getMatterCache(branch, file) {
+        if (!this.registry) {
+            throw new Error('IDRegistryService not initialized. Call init() first.');
+        }
+        const cacheKey = `${branch}:${file}`;
+        const cached = this.registry.matters[cacheKey];
+        if (!cached) {
+            return undefined;
+        }
+        // Retourner uniquement les champs publics (sans 'updated')
+        return {
+            id: cached.id,
+            title: cached.title,
+            service: cached.service,
+            oldfile: cached.oldfile // FIXME (check if needed) ✅ Inclure oldfile temporaire si présent
+        };
+    }
+    /**
+     * Met à jour le cache d'un matter
+     */
+    setMatterCache(branch, file, matter) {
+        if (!this.registry) {
+            throw new Error('IDRegistryService not initialized. Call init() first.');
+        }
+        const cacheKey = `${branch}:${file}`;
+        this.registry.matters[cacheKey] = {
+            id: matter.id,
+            title: matter.title,
+            service: matter.service,
+            oldfile: matter.oldfile, // ✅ Inclure oldfile temporaire
+            updated: new Date().toISOString()
+        };
+        this.isDirty = true;
+    }
+    /**
+     * Supprime une entrée du cache
+     */
+    deleteMatterCache(branch, file) {
+        if (!this.registry) {
+            throw new Error('IDRegistryService not initialized. Call init() first.');
+        }
+        const cacheKey = `${branch}:${file}`;
+        delete this.registry.matters[cacheKey];
+        this.isDirty = true;
+    }
+    /**
+     * Renomme une entrée dans le cache du registre
+     *
+     * Cette méthode gère le renommage d'un fichier dans le cache:
+     * - Supprime l'ancienne clé `${branch}:${oldFile}`
+     * - Crée une nouvelle clé `${branch}:${newFile}` avec les mêmes données
+     * - 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
+     *
+     * @example
+     * ```typescript
+     * // Après un rename Git
+     * idRegistryService.rename('old-name.md', 'new-name.md', 'rule-validation-1');
+     * ```
+     */
+    rename(oldFile, newFile, branch) {
+        if (!this.registry) {
+            throw new Error('IDRegistryService not initialized. Call init() first.');
+        }
+        const oldKey = `${branch}:${oldFile}`;
+        const newKey = `${branch}:${newFile}`;
+        // Récupérer le cache existant
+        const cached = this.registry.matters[oldKey];
+        if (!cached) {
+            // Pas de cache pour l'ancien fichier, rien à renommer
+            return;
+        }
+        // Supprimer l'ancienne clé
+        delete this.registry.matters[oldKey];
+        //
+        // Créer la nouvelle clé avec les mêmes données
+        // ⚠️ NE PAS inclure oldfile - c'est temporaire uniquement pour notification client
+        this.registry.matters[newKey] = {
+            id: cached.id,
+            title: cached.title,
+            service: cached.service,
+            updated: new Date().toISOString()
+        };
+        this.isDirty = true;
+    }
+}
+IDRegistryService.instance = null;
+// ✅ Instance singleton du service
+const idRegistryService = IDRegistryService.get();
+/**
+ * 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()
+ * }
+ * ```
+ */
+function gitIDRegistryExists(config) {
+    const gitConf = (0, repo_tools_1.gitLoad)(config);
+    const registryPath = (0, path_1.join)(gitConf.repoPath, '.git', 'with-ids.json');
+    return (0, fs_1.existsSync)(registryPath);
+}
+/**
+ * Génère un nouvel ID unique en incrémentant de +20
+ * @param config Configuration Git optionnelle
+ * @returns Un nouvel ID unique
+ */
+function gitGenerateNextID(config) {
+    const gitConf = (0, repo_tools_1.gitLoad)(config);
+    idRegistryService.init(gitConf.repoPath);
+    const newID = idRegistryService.generateNextID();
+    // FIXME: Double save - gitGenerateNextID() et gitRegisterExistingID() appellent tous deux save()
+    // Refactorisation future: Retirer save() d'ici et le faire uniquement dans gitRegisterExistingID()
+    // quand matter est fourni (processus atomique: generate → setCache → register → save)
+    idRegistryService.save();
+    return newID;
+}
+/**
+ * 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
+ * ```
+ */
+function gitReloadIDRegistry(config) {
+    const gitConf = (0, repo_tools_1.gitLoad)(config);
+    if (config?.reset) {
+        idRegistryService.clear();
+    }
+    idRegistryService.init(gitConf.repoPath);
+    idRegistryService.forceReload();
+}
+/**
+ * Enregistre un ID existant dans le registre
+ *
+ * @param 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.
+ */
+function gitRegisterExistingID(matter, branch, file, config) {
+    const gitConf = (0, repo_tools_1.gitLoad)(config);
+    idRegistryService.init(gitConf.repoPath);
+    // ✅ Validation: matter doit avoir id et title
+    if (!matter.id || !matter.title) {
+        throw new errors_1.GitOperationError('Le matter est invalide (id et title requis)', 'invalid_matter');
+    }
+    // ✅ IMPORTANT: Vérifier AVANT de mettre à jour le cache
+    // Si l'ID existe déjà, vérifier qu'il appartient au MÊME fichier
+    const registry = idRegistryService.getRegistry();
+    if (registry.used.includes(matter.id)) {
+        const ownerFile = idRegistryService.getFileByID(matter.id);
+        if (ownerFile && ownerFile !== file) {
+            // ID utilisé par un AUTRE fichier → Erreur
+            const error = new Error(`ID ${matter.id} est déjà utilisé`);
+            error.code = 'id_already_used';
+            throw error;
+        }
+        // Même fichier OU pas de fichier dans le cache → OK, continuer
+    }
+    // ✅ Mettre à jour le cache (maintenant qu'on sait que l'ID est valide)
+    if (branch && file) {
+        idRegistryService.setMatterCache(branch, file, matter);
+    }
+    // ✅ Enregistrer l'ID dans used[] si pas déjà dedans
+    idRegistryService.registerExistingID(matter.id, branch, file);
+    idRegistryService.save();
+}
+/**
+ * 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');
+ * ```
+ */
+function gitIDRegistryRename(oldFile, newFile, branch, config) {
+    const gitConf = (0, repo_tools_1.gitLoad)(config);
+    idRegistryService.init(gitConf.repoPath);
+    idRegistryService.rename(oldFile, newFile, branch);
+    idRegistryService.save();
+}
+/**
+ * Valide et assure qu'un matter a un ID valide
+ *
+ * **Principe d'identité stable**: Un fichier conserve son ID à travers les branches.
+ * Cette fonction cherche d'abord si le fichier a déjà un ID dans le registre
+ * (peu importe la branche), et le réutilise pour garantir la cohérence.
+ *
+ * @param matter Le matter à valider/compléter
+ * @param config Configuration Git optionnelle
+ * @param branch Branche du fichier (optionnel, peut être undefined lors de createPullRequest)
+ * @param file Nom du fichier (requis pour chercher l'ID existant)
+ * @returns Le matter mis à jour avec un ID valide
+ */
+function gitEnsureMatterID(matter, config, branch, file) {
+    const gitConf = (0, repo_tools_1.gitLoad)(config);
+    idRegistryService.init(gitConf.repoPath);
+    // ✅ NOUVEAU: Chercher d'abord l'ID existant du fichier (peu importe la branche)
+    const existingFileID = file ? idRegistryService.getFileID(file) : undefined;
+    if (existingFileID) {
+        // Le fichier a déjà un ID → le réutiliser pour garantir la cohérence
+        matter.id = existingFileID;
+        // Mettre à jour le cache si branch est définie (sinon ce sera fait plus tard)
+        if (branch && file && matter.title) {
+            idRegistryService.setMatterCache(branch, file, {
+                id: matter.id,
+                title: matter.title,
+                service: matter.service
+            });
+        }
+        return matter;
+    }
+    // Si matter a un ID fourni manuellement (ex: import ou test)
+    // FIXME 999 should be a constant in config
+    if (matter.id && typeof matter.id === 'number' && matter.id > 999) {
+        try {
+            // Essayer d'enregistrer cet ID
+            gitRegisterExistingID(matter, branch, file, config);
+            return matter;
+        }
+        catch (error) {
+            // ID déjà utilisé par un AUTRE fichier → générer un nouveau
+            // (Si même fichier, registerExistingID ne lève pas d'erreur)
+        }
+    }
+    // Générer un nouvel ID
+    matter.id = gitGenerateNextID(config);
+    // FIXME: Double save ici - gitGenerateNextID() fait save() puis gitRegisterExistingID() fait save() aussi
+    // Refactorisation future: Retirer save() de gitGenerateNextID() et le faire uniquement dans gitRegisterExistingID()
+    // quand matter est fourni (processus atomique: generate → setCache → register → save)
+    // ✅ Mettre à jour le cache avec le nouvel ID (seulement si branch est définie)
+    if (branch && file && matter.title) {
+        idRegistryService.setMatterCache(branch, file, {
+            id: matter.id,
+            title: matter.title,
+            service: matter.service
+        });
+    }
+    return matter;
+}
+/**
+ * Valide le format du matter (ID et title obligatoires)
+ * @param matter Le matter à valider
+ * @throws GitOperationError si le matter est invalide
+ */
+function validateMatter(matter) {
+    if (!matter || typeof matter !== 'object') {
+        throw new errors_1.GitOperationError('Le matter est invalide', 'invalid_matter');
+    }
+    //
+    // ✅ FIX: Vérifier que l'ID existe et est un nombre
+    if (!matter.id || typeof matter.id !== 'number') {
+        throw new errors_1.GitOperationError('Le matter doit contenir un champ "id" de type number', 'missing_id', { matter });
+    }
+    if (matter.id <= 999) {
+        throw new errors_1.GitOperationError(`L'ID ${matter.id} est réservé (doit être >= 1000)`, 'invalid_id', { id: matter.id });
+    }
+    if (!matter.title || typeof matter.title !== 'string') {
+        throw new errors_1.GitOperationError('Le matter doit contenir un champ "title" de type string', 'missing_title', { matter });
+    }
+}
+/**
+ * Extraction rapide du matter depuis une chaîne de contenu (helper interne)
+ * @internal
+ */
+function extractMatterFromContent(content) {
+    if (!content) {
+        return { id: 0, title: undefined, service: undefined, oldfile: undefined };
+    }
+    // Regex pour extraire id (format: "id: 1234" ou "id: '1234'")
+    const idMatch = content.match(/^id:\s*['"]?(\d+)['"]?/m);
+    const id = idMatch ? parseInt(idMatch[1], 10) : undefined;
+    // Regex pour extraire title (format: "title: Mon Titre" ou "title: 'Mon Titre'")
+    const titleMatch = content.match(/^title:\s*["']?([^"'\n]+)["']?/m);
+    const title = titleMatch ? titleMatch[1].trim() : undefined;
+    const serviceMatch = content.match(/^service:\s*["']?([^"'\n]+)["']?/m);
+    const service = serviceMatch ? serviceMatch[1].trim() : undefined;
+    //
+    // ✅ Extraction de oldfile (champ temporaire pour notifier les renames)
+    const oldfileMatch = content.match(/^oldfile:\s*["']?([^"'\n]+)["']?/m);
+    const oldfile = oldfileMatch ? oldfileMatch[1].trim() : undefined;
+    return { id, title, service, oldfile };
+}
+/**
+ * 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"
+ * ```
+ */
+async function gitFileStrictMatter(git, filePath, branch, config) {
+    const gitConf = (0, repo_tools_1.gitLoad)(config);
+    idRegistryService.init(gitConf.repoPath);
+    try {
+        // ✅ ÉTAPE 1: Vérifier le cache
+        const cached = idRegistryService.getMatterCache(branch, filePath);
+        if (cached) {
+            // Cache trouvé, retourner directement
+            return {
+                id: cached.id,
+                title: cached.title,
+                oldfile: cached.oldfile // ✅ Inclure oldfile temporaire
+            };
+        }
+        // ❌ ÉTAPE 2: Cache absent, lire le fichier
+        const content = await git.show([`${branch}:${filePath}`]);
+        if (!content) {
+            return { id: undefined, title: undefined, oldfile: undefined };
+        }
+        // ✅ ÉTAPE 3: Extraction rapide avec regex (sans matterParse complet)
+        const matter = extractMatterFromContent(content);
+        // ✅ ÉTAPE 4: Mettre à jour le cache
+        idRegistryService.setMatterCache(branch, filePath, matter);
+        idRegistryService.save();
+        return matter;
+    }
+    catch (error) {
+        if (gitConf.verbose) {
+            console.warn(`⚠️ Erreur lecture matter de ${filePath}:`, error);
+        }
+        return { id: undefined, title: undefined, oldfile: undefined };
+    }
+}
 /**
  * Vérifie et configure un repository Git existant pour s'assurer qu'il a la configuration requise
  * @param git Instance SimpleGit
@@ -391,6 +1015,64 @@ async function gitCreateOrEditFile(git, filePath, PR, content, user, config) {
     let currentBranch;
     try {
         const gitConf = (0, repo_tools_1.gitLoad)(config);
+        // ===== VALIDATION DES IDs (si activée) =====
+        if (gitConf.withID) {
+            try {
+                // Import dynamique pour éviter les dépendances circulaires
+                const { matterParse, matterSerialize } = await Promise.resolve().then(() => __importStar(require('../utils.matter')));
+                const parsed = matterParse(content);
+                if (gitConf.strictID) {
+                    // Mode strict : valider que l'ID existe et est correct
+                    validateMatter(parsed.matter);
+                    // ✅ gitRegisterExistingID() appelle maintenant setMatterCache() automatiquement si matter est fourni
+                    // Enregistrer l'ID existant
+                    // ✅ Passer branch (PR) et file (filePath) pour vérifier propriété
+                    gitRegisterExistingID(parsed.matter, PR, filePath, gitConf);
+                }
+                else {
+                    // Mode permissif : générer l'ID si manquant
+                    // ✅ IMPORTANT: Ne PAS ré-assigner l'ID s'il est déjà valide
+                    // Le contenu a peut-être déjà été traité par gitEnsureMatterID() dans le caller
+                    const hasValidID = parsed.matter.id &&
+                        typeof parsed.matter.id === 'number' &&
+                        parsed.matter.id > 999;
+                    if (!hasValidID) {
+                        // Seulement si l'ID est manquant ou invalide
+                        parsed.matter = gitEnsureMatterID(parsed.matter, gitConf, PR, filePath);
+                        // Re-sérialiser avec l'ID mis à jour
+                        content = matterSerialize(parsed.content, parsed.matter);
+                    }
+                    else {
+                        // ✅ L'ID existe déjà : gitRegisterExistingID() appelle maintenant setMatterCache() automatiquement
+                        try {
+                            gitRegisterExistingID(parsed.matter, PR, filePath, gitConf);
+                        }
+                        catch (error) {
+                            // Si l'ID est déjà utilisé par un autre fichier, générer un nouvel ID
+                            if (error.code === 'id_already_used') {
+                                // En mode non-strict, générer un nouvel ID si doublon détecté
+                                parsed.matter = gitEnsureMatterID(parsed.matter, gitConf, PR, filePath);
+                                content = matterSerialize(parsed.content, parsed.matter);
+                                // ✅ Ne pas propager l'erreur, continuer avec le nouvel ID généré
+                            }
+                            else {
+                                throw error;
+                            }
+                        }
+                    }
+                }
+            }
+            catch (error) {
+                // En mode strict, propager l'erreur id_already_used
+                // En mode permissif, cette erreur devrait déjà être gérée dans le bloc ci-dessus
+                if (error.code === 'id_already_used' && gitConf.strictID) {
+                    throw new errors_1.GitOperationError(`Impossible de créer le fichier: ${error.message}`, 'duplicate_id', { filePath, error });
+                }
+                // Propager les autres erreurs de validation
+                throw error;
+            }
+        }
+        // ===== FIN VALIDATION IDs =====
         //
         // secure main and draft branches (on production)
         if (!gitConf?.canForce && PR == gitConf.mainBranch) {
@@ -408,6 +1090,26 @@ async function gitCreateOrEditFile(git, filePath, PR, content, user, config) {
         // without note the branche is not a valid PR branch
         const oldNote = await (0, repo_tools_1.gitReadNote)(git, PR, gitConf.gitNotes.namespace, 10);
         const commit = await _writeFileAndCommit(git, filePath, content, user, gitConf, `commit: ${filePath}`);
+        // ✅ Mettre à jour le cache du matter après sauvegarde
+        // NOTE: Le cache est TOUJOURS mis à jour, indépendamment de withID
+        // C'est une opération de cache, pas une validation
+        try {
+            const { matterParse } = await Promise.resolve().then(() => __importStar(require('../utils.matter')));
+            const parsed = matterParse(content);
+            idRegistryService.init(gitConf.repoPath);
+            idRegistryService.setMatterCache(PR, filePath, {
+                id: parsed.matter.id,
+                title: parsed.matter.title
+                // ⚠️ Ne PAS persister oldfile dans le cache - temporaire uniquement pour client
+            });
+            idRegistryService.save();
+        }
+        catch (cacheError) {
+            // Erreur non critique, ne pas bloquer la sauvegarde
+            if (gitConf.verbose) {
+                console.warn('⚠️ Erreur mise à jour cache matter:', cacheError);
+            }
+        }
         if (!oldNote) {
             return {
                 hash: commit.commit,
@@ -862,6 +1564,81 @@ async function gitGetBranchHealth(git, branch) {
         (health.clean || (health.modifiedFiles === 0 && health.stagedFiles === 0));
     return health;
 }
+/**
+ * Version optimisée de gitGetBranchHealth pour les branches de validation
+ *
+ * Cette fonction utilise une approche en cascade pour diagnostiquer rapidement
+ * l'état d'une branche de validation sans effectuer de checkout coûteux.
+ *
+ * Tests effectués dans l'ordre (arrêt au premier échec) :
+ * 1. Branche existe ? (git rev-parse --verify)
+ * 2. Note Git présente sur HEAD ? (gitReadNote avec maxCommit=1)
+ * 3. Note correspond au bon PR ? (note.id === prNumber)
+ *
+ * Avantages :
+ * - ✅ Pas de checkout (gain 80-90% performance)
+ * - ✅ Lecture directe du HEAD sans changer de branche
+ * - ✅ Tests cascade (arrêt dès qu'un problème est détecté)
+ * - ✅ Optimisé pour branches temporaires (validations)
+ *
+ * @param git Instance SimpleGit
+ * @param branch Nom de la branche de validation à diagnostiquer
+ * @param config Configuration Git optionnelle
+ * @returns GitHealthStatus avec diagnostic optimisé
+ */
+async function gitGetValidationBranchHealth(git, branch, config) {
+    const gitConfig = config || (0, repo_tools_1.gitLoad)();
+    const health = {
+        branch,
+        exists: false,
+        accessible: false,
+        clean: true, // Par défaut OK pour validation (pas de working dir check)
+        mergeInProgress: false,
+        conflictedFiles: 0,
+        modifiedFiles: 0,
+        untrackedFiles: 0,
+        stagedFiles: 0,
+        indexReadable: true,
+        healthy: false,
+        issues: [],
+        recommendations: []
+    };
+    try {
+        // 1. CASCADE: Vérifier existence (très rapide, sans checkout)
+        const branchExists = await git.raw(['rev-parse', '--verify', branch])
+            .then(() => true)
+            .catch(() => false);
+        if (!branchExists) {
+            health.issues.push(`Branche '${branch}' n'existe pas`);
+            health.recommendations.push(`Créer la branche ou vérifier le nom`);
+            return health;
+        }
+        health.exists = true;
+        health.accessible = true; // Si rev-parse OK, branche accessible
+        // 2. CASCADE: Vérifier note sur HEAD (rapide, sans checkout)
+        const headCommit = await git.raw(['rev-parse', branch]).then(s => s.trim());
+        const note = await (0, repo_tools_1.gitReadNote)(git, headCommit, gitConfig.gitNotes.namespace, 1);
+        if (!note) {
+            health.issues.push(`Pas de note Git sur HEAD de '${branch}'`);
+            health.recommendations.push(`Note perdue, utiliser git-notes-list-lost.sh pour la localiser`);
+            return health;
+        }
+        // 3. CASCADE: Vérifier que la note correspond au PR
+        const prNumber = parseInt(branch.split('-').pop() || '0', 10);
+        if (note.id !== prNumber) {
+            health.issues.push(`Note incorrecte: ID=${note.id}, attendu PR=${prNumber}`);
+            health.recommendations.push(`Corriger la note ou supprimer la branche`);
+            return health;
+        }
+        // ✅ Tous les tests essentiels passés
+        health.healthy = true;
+    }
+    catch (error) {
+        health.issues.push(`Erreur diagnostic: ${error.message}`);
+        health.recommendations.push(`Vérifier l'état du dépôt Git`);
+    }
+    return health;
+}
 /**
  * Fonction helper pour créer un statut unhealthy
  */