agentic-api 2.0.31 → 2.0.491

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

@@ -0,0 +1,1390 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RAGManager = void 0;
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const types_1 = require("./types");
+const embeddings_1 = require("./embeddings");
+const parser_1 = require("./parser");
+const usecase_1 = require("./usecase");
+/** Configuration RAG par défaut */
+const DEFAULT_RAG_CONFIG = {
+    dimensions: 1536,
+    distance: 'cosine',
+    version: '1.0',
+    startId: 1000,
+    hnswConfig: { ef: 200, m: 32 }
+};
+const DEFAULT_RAG_INSTANCE = {};
+/**
+ * Gestionnaire multi-RAG stateless pour gérer plusieurs index RAG
+ */
+class RAGManager {
+    constructor(config) {
+        this.cachedRegistry = null;
+        this.lastLoadTime = 0;
+        /**
+         * Map des embeddings chargés pour permettre les updates réactifs
+         * Note: Pour une meilleure gestion mémoire, appeler cleanDeadReferences() périodiquement
+         */
+        this.loadedEmbeddings = new Map();
+        if (!config.baseDir || !(0, fs_1.existsSync)(config.baseDir)) {
+            throw new Error(`Le dossier du registre RAG n'existe pas: ${config.baseDir}`);
+        }
+        this.config = {
+            tempDir: path_1.default.join(config.baseDir, 'temp'),
+            archiveDir: path_1.default.join(config.baseDir, 'archives'),
+            maxArchives: 5,
+            ...config
+        };
+        this.registryFile = path_1.default.join(this.config.baseDir, 'registry.json');
+        // Créer les dossiers nécessaires
+        this.ensureDirectories();
+        // Charger le registre initial
+        this.loadRegistry();
+        //
+        // store instance in memory
+        DEFAULT_RAG_INSTANCE[this.config.baseDir] = this;
+        const registry = this.getRegistry();
+        const defaultName = registry.defaultName || 'RAGRegistry';
+        DEFAULT_RAG_INSTANCE[defaultName] = this;
+    }
+    static get(config) {
+        // Vérifier si une instance existe déjà pour ce baseDir
+        if (DEFAULT_RAG_INSTANCE[config.baseDir]) {
+            return DEFAULT_RAG_INSTANCE[config.baseDir];
+        }
+        // Créer une nouvelle instance
+        return new RAGManager(config);
+    }
+    /**
+     * Nettoie le cache des instances (utile pour les tests)
+     */
+    static clearCache() {
+        Object.keys(DEFAULT_RAG_INSTANCE).forEach(key => {
+            delete DEFAULT_RAG_INSTANCE[key];
+        });
+    }
+    /**
+     * Crée les dossiers nécessaires s'ils n'existent pas
+     */
+    ensureDirectories() {
+        [this.config.baseDir, this.config.tempDir, this.config.archiveDir].forEach(dir => {
+            if (!(0, fs_1.existsSync)(dir)) {
+                (0, fs_1.mkdirSync)(dir, { recursive: true });
+            }
+        });
+    }
+    /**
+     * Charge le registre depuis le fichier JSON et scan les dossiers
+     */
+    loadRegistry() {
+        this.lastLoadTime = Date.now();
+        // Charger le registre existant ou créer un nouveau
+        let registry;
+        if ((0, fs_1.existsSync)(this.registryFile)) {
+            try {
+                registry = JSON.parse((0, fs_1.readFileSync)(this.registryFile, 'utf8'));
+            }
+            catch (error) {
+                console.warn('Erreur lors du chargement du registre, création d\'un nouveau:', error);
+                registry = {
+                    version: '1.0',
+                    registries: {},
+                    defaultName: 'RAGRegistry'
+                };
+            }
+        }
+        else {
+            registry = {
+                version: '1.0',
+                registries: {},
+                defaultName: 'RAGRegistry'
+            };
+        }
+        // Définir defaultName par défaut s'il n'est pas défini
+        if (!registry.defaultName) {
+            registry.defaultName = 'RAGRegistry';
+        }
+        // Scanner les dossiers pour découvrir les RAG existants
+        this.scanDirectoriesForRAGs(registry);
+        // Sauvegarder le registre mis à jour (seulement si des changements détectés)
+        this.saveRegistry(registry);
+        // Mettre en cache
+        this.cachedRegistry = registry;
+        return registry;
+    }
+    /**
+     * Scanne les dossiers pour découvrir les RAG existants
+     */
+    scanDirectoriesForRAGs(registry) {
+        if (!(0, fs_1.existsSync)(this.config.baseDir)) {
+            return;
+        }
+        const entries = (0, fs_1.readdirSync)(this.config.baseDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.isDirectory() &&
+                entry.name !== 'temp' &&
+                entry.name !== 'archives' &&
+                entry.name !== 'registry.json') {
+                const ragPath = path_1.default.join(this.config.baseDir, entry.name);
+                const metadataFile = path_1.default.join(ragPath, 'rag-metadata.json');
+                // Vérifier si c'est un dossier RAG valide
+                if ((0, fs_1.existsSync)(metadataFile)) {
+                    // Lire les métadonnées pour obtenir le nom d'alias potentiel
+                    let aliasName;
+                    try {
+                        const metadata = JSON.parse((0, fs_1.readFileSync)(metadataFile, 'utf8'));
+                        aliasName = metadata.name || metadata.displayName;
+                    }
+                    catch (e) {
+                        // Ignorer les erreurs de parsing
+                    }
+                    // Ajouter ou mettre à jour l'entrée dans le registre
+                    if (!registry.registries[entry.name]) {
+                        const ragEntry = {
+                            name: aliasName || entry.name, // Utiliser l'alias si disponible
+                            configPath: ragPath,
+                            status: 'active'
+                        };
+                        // Ajouter sous la clé du dossier
+                        registry.registries[entry.name] = ragEntry;
+                        // Ajouter aussi sous l'alias si différent
+                        if (aliasName && aliasName !== entry.name) {
+                            registry.registries[aliasName] = ragEntry;
+                        }
+                    }
+                    else {
+                        // Mettre à jour le chemin si nécessaire
+                        registry.registries[entry.name].configPath = ragPath;
+                        // Mettre à jour aussi l'alias si présent
+                        const existingName = registry.registries[entry.name].name;
+                        if (existingName && existingName !== entry.name && registry.registries[existingName]) {
+                            registry.registries[existingName].configPath = ragPath;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * Vérifie si un RAG existe dans le registre (peu importe son statut)
+     * Recherche par clé du dictionnaire OU par entry.name
+     */
+    exists(name) {
+        const registry = this.getRegistry();
+        // Chercher d'abord par clé (comportement normal)
+        const entry = name in registry.registries || Object.values(registry.registries).some(entry => entry.name === name);
+        return entry;
+    }
+    /**
+     * Obtient le registre en cache ou le recharge si nécessaire
+     */
+    getRegistry() {
+        const timeout = 3600 * 4; // 4 hours
+        if (!this.cachedRegistry || Date.now() - this.lastLoadTime > timeout) {
+            return this.loadRegistry();
+        }
+        return this.cachedRegistry;
+    }
+    /**
+     * Sauvegarde le registre dans le fichier JSON
+     */
+    saveRegistry(registry) {
+        try {
+            this.cachedRegistry = registry;
+            (0, fs_1.writeFileSync)(this.registryFile, JSON.stringify(registry, null, 2), 'utf8');
+        }
+        catch (error) {
+            console.error('Erreur lors de la sauvegarde du registre RAG:', error);
+            throw new Error(`Impossible de sauvegarder le registre RAG: ${error}`);
+        }
+    }
+    /**
+     * Notifie les embeddings chargés de se mettre à jour
+     *
+     * @param name Nom du RAG à mettre à jour
+     * @param opts Options de mise à jour (action: 'rename' pour renommer un document)
+     *
+     * FIXME: Gérer le cas où l'embedding est en cours d'exécution (recherche/indexation)
+     * Actuellement, l'update est appelé immédiatement sans vérifier si l'embedding est busy.
+     * Solutions possibles:
+     * - Ajouter un flag `isBusy` dans Embeddings
+     * - Implémenter une queue d'updates
+     * - Utiliser un système de locks
+     *
+     * @example
+     * ```typescript
+     * // Après un build
+     * this.notifyUpdate('procedures-stable');
+     *
+     * // Après un rename de document
+     * this.notifyUpdate('procedures-stable', {
+     *   action: 'rename',
+     *   oldFile: 'old.md',
+     *   newFile: 'new.md'
+     * });
+     * ```
+     */
+    notifyUpdate(name, opts) {
+        const embeddingData = this.loadedEmbeddings.get(name);
+        console.log(`\n🔔 notifyUpdate('${name}') appelé`);
+        console.log(`   Embedding en cache: ${embeddingData ? 'OUI' : 'NON'}`);
+        // Si l'embedding n'est pas encore chargé, rien à faire
+        // Il sera chargé avec la nouvelle config au prochain load()
+        if (!embeddingData) {
+            console.log(`   ⏭️  Skip: sera chargé avec la nouvelle config au prochain load()`);
+            return;
+        }
+        // Charger la nouvelle configuration depuis le registre
+        const entry = this.getEntry(name);
+        if (!entry) {
+            console.log(`   ⚠️  Entry '${name}' introuvable dans le registre`);
+            return;
+        }
+        console.log(`   📁 entry.configPath: ${entry.configPath}`);
+        // L'embedding est chargé, forcer son rechargement via update()
+        // update() modifie l'instance EN PLACE, donc tous ceux qui ont une référence voient la nouvelle version
+        const { embedding } = embeddingData;
+        try {
+            const newConfig = this.loadConfig(entry.configPath);
+            console.log(`   🔄 Appel de embedding.update() avec baseDir: ${newConfig.baseDir}`);
+            // FIXME: Vérifier si l'embedding est busy avant de faire l'update
+            // update() va recharger l'index, les métadonnées et le mapping depuis newConfig.baseDir
+            // update() modifie l'instance en place, donc tous les utilisateurs voient la nouvelle version
+            embedding.update(newConfig);
+            // Mettre à jour le timestamp du cache
+            embeddingData.loadTime = Date.now();
+            console.log(`   ✅ Embedding rechargé avec succès`);
+            console.log(`   ✅ embedding.isReady(): ${embedding.isReady()}`);
+        }
+        catch (error) {
+            console.error(`   ❌ Erreur lors de la mise à jour de l'embedding '${name}':`, error);
+            // En cas d'erreur, update() a déjà fait un rollback de sa propre config
+            // L'instance continue de fonctionner avec l'ancienne config
+            // Ne pas throw pour éviter de bloquer le flow
+        }
+    }
+    /**
+     * Génère un nom d'archive avec timestamp YYYMMDD
+     */
+    generateArchiveName(name) {
+        const timestamp = new Date().toISOString().slice(0, 10).replace(/-/g, '');
+        return `${name}-${timestamp}`;
+    }
+    /**
+     * Archive un RAG existant
+     */
+    async archive(name) {
+        const entry = this.getEntry(name);
+        if (!entry || !(0, fs_1.existsSync)(entry.configPath)) {
+            return null;
+        }
+        const archiveName = this.generateArchiveName(name);
+        const archivePath = path_1.default.join(this.config.archiveDir, archiveName);
+        try {
+            // Copier le dossier vers les archives
+            (0, fs_1.renameSync)(entry.configPath, archivePath);
+            if (this.config.verbose)
+                console.log(`✅ RAG archivé: ${name} -> ${archiveName}`);
+            // Nettoyer les anciennes archives si nécessaire
+            await this.cleanOldArchives(name);
+            return archiveName;
+        }
+        catch (error) {
+            console.error(`Erreur lors de l'archivage de ${name}:`, error);
+            return null;
+        }
+    }
+    /**
+     * Charge la configuration depuis le fichier metadata
+     */
+    loadConfig(configPath) {
+        const metadataFile = path_1.default.join(configPath, 'rag-metadata.json');
+        if (!(0, fs_1.existsSync)(metadataFile)) {
+            throw new Error(`Fichier metadata manquant: ${metadataFile}`);
+        }
+        try {
+            const metadata = JSON.parse((0, fs_1.readFileSync)(metadataFile, 'utf8'));
+            // Extraire la configuration depuis les métadonnées
+            const ragConfig = {
+                baseDir: configPath,
+                dimensions: metadata.config?.dimensions || 1536,
+                distance: metadata.config?.distance || 'cosine',
+                version: metadata.config?.version || metadata.version || '1.0',
+                startId: metadata.config?.startId || 1000,
+                hnswConfig: metadata.config?.hnswConfig || { ef: 200, m: 32 }
+            };
+            return ragConfig;
+        }
+        catch (error) {
+            throw new Error(`Erreur lors du chargement de la configuration RAG: ${error}`);
+        }
+    }
+    /**
+     * Sauvegarde les métadonnées RAG dans un dossier
+     *
+     * @param dirPath Chemin du dossier où sauvegarder les métadonnées
+     * @param metadata Métadonnées complètes du RAG
+     * @private
+     */
+    saveMetadata(dirPath, metadata) {
+        const metadataFile = path_1.default.join(dirPath, types_1.RAG_FILES.METADATA);
+        try {
+            (0, fs_1.writeFileSync)(metadataFile, JSON.stringify(metadata, null, 2), 'utf8');
+            if (this.config.verbose) {
+                console.log(`✅ Métadonnées sauvegardées: ${metadataFile}`);
+            }
+        }
+        catch (error) {
+            throw new Error(`Échec de la sauvegarde des métadonnées: ${error}`);
+        }
+    }
+    /**
+     * Sauvegarde le mapping RAG dans un dossier
+     *
+     * @param dirPath Chemin du dossier où sauvegarder le mapping
+     * @param mapping Mapping ID → ref des sections
+     * @param buildResult Résultat de la construction pour les métadonnées du mapping
+     * @private
+     */
+    saveMapping(dirPath, mapping, buildResult) {
+        const mappingFile = path_1.default.join(dirPath, types_1.RAG_FILES.MAPPING);
+        const mappingData = {
+            type: 'mapping',
+            version: buildResult.version,
+            tag: buildResult.tag,
+            mapping,
+            createdAt: new Date().toISOString()
+        };
+        try {
+            (0, fs_1.writeFileSync)(mappingFile, JSON.stringify(mappingData, null, 2), 'utf8');
+            if (this.config.verbose) {
+                console.log(`✅ Mapping sauvegardé: ${mappingFile}`);
+            }
+        }
+        catch (error) {
+            throw new Error(`Échec de la sauvegarde du mapping: ${error}`);
+        }
+    }
+    /**
+     * Nettoie les anciennes archives d'un RAG
+     */
+    async cleanOldArchives(name) {
+        if (!this.config.maxArchives || this.config.maxArchives <= 0)
+            return;
+        try {
+            const archives = (0, fs_1.readdirSync)(this.config.archiveDir)
+                .filter(dir => dir.startsWith(`${name}-`))
+                .sort()
+                .reverse(); // Plus récent en premier
+            if (archives.length > this.config.maxArchives) {
+                const toDelete = archives.slice(this.config.maxArchives);
+                for (const archive of toDelete) {
+                    const archivePath = path_1.default.join(this.config.archiveDir, archive);
+                    (0, fs_1.rmSync)(archivePath, { recursive: true, force: true });
+                    console.log(`🗑️ Archive supprimée: ${archive}`);
+                }
+            }
+        }
+        catch (error) {
+            console.warn(`Erreur lors du nettoyage des archives pour ${name}:`, error);
+        }
+    }
+    /**
+     * Récupère l'entrée d'un RAG dans le registre
+     *
+     * @param name Nom du RAG
+     * @returns L'entrée du registre ou undefined si non trouvé
+     */
+    getEntry(name) {
+        const registry = this.getRegistry();
+        // Chercher d'abord par clé (comportement normal)
+        const entry = registry.registries[name] || Object.values(registry.registries).find(e => e.name === name);
+        return entry;
+    }
+    /**
+     * Crée un nouveau RAG dans le registre et retourne le chemin temporaire
+     *
+     * Le registre stocke:
+     * - configPath: le tempPath (source de construction)
+     * - destDir: le chemin de destination finale
+     * - status: 'building'
+     * - description: label descriptif court (optionnel)
+     *
+     * Après build(), configPath sera remplacé par destDir et status = 'active'
+     *
+     * @param name Nom du RAG
+     * @param options Options de création
+     * @returns Chemin du dossier temporaire créé
+     *
+     * @example
+     * ```typescript
+     * // Création simple
+     * await ragManager.create('my-rag', { description: 'Mon RAG' });
+     *
+     * // Création avec fork
+     * await ragManager.create('child-rag', {
+     *   description: 'PR validation',
+     *   fork: 'parent-rag',
+     *   exclude: ['modif-1.md', 'modif-2.md']
+     * });
+     * ```
+     */
+    async create(name, options) {
+        if (this.exists(name)) {
+            throw new Error(`RAG '${name}' existe déjà`);
+        }
+        // Support legacy: string → description
+        const opts = typeof options === 'string' ? { description: options } : (options || {});
+        // Créer dossier temporaire avec timestamp
+        const tempPath = path_1.default.join(this.config.tempDir, `${name}-${Date.now()}`);
+        (0, fs_1.mkdirSync)(tempPath, { recursive: true });
+        // Chemin de destination finale
+        const destDir = path_1.default.join(this.config.baseDir, name);
+        // Créer l'entrée dans le registre
+        const registry = this.getRegistry();
+        registry.registries[name] = {
+            name,
+            configPath: tempPath, // Source temporaire (tant que building)
+            destDir: destDir, // Destination finale (pour après build)
+            status: 'building',
+            description: opts.description, // Label descriptif court
+            checkpoint: opts.checkpoint // Hash du dernier commit
+        };
+        // Définir comme défaut si c'est le premier
+        if (Object.keys(registry.registries).length === 1) {
+            registry.defaultName = name;
+        }
+        this.saveRegistry(registry);
+        if (this.config.verbose)
+            console.log(`✅ RAG créé: ${name} (temp: ${tempPath}, dest: ${destDir})`);
+        // Si option fork, copier les documents du parent
+        if (opts.fork) {
+            if (this.config.verbose) {
+                console.log(`🔄 Fork depuis '${opts.fork}'...`);
+            }
+            const forkResult = this.fork(opts.fork, name, { exclude: opts.exclude });
+            if (this.config.verbose) {
+                console.log(`✅ Fork terminé: ${forkResult.documents} documents copiés (${forkResult.files} fichiers)`);
+            }
+        }
+        return tempPath; // Retourner le chemin temp
+    }
+    /**
+     * Sauvegarde un document dans le dossier de construction d'un RAG
+     *
+     * Le registre est consulté pour trouver le dossier (configPath en mode building)
+     *
+     * @param name Nom du RAG
+     * @param filename Nom du fichier (ex: 'my-document.md')
+     * @param content Contenu markdown avec front-matter
+     *
+     * @example
+     * ```typescript
+     * await ragManager.create('my-rag');
+     * ragManager.addDocument('my-rag', 'procedure.md', markdownContent);
+     * ```
+     */
+    addDocument(name, filename, content) {
+        // Récupérer le chemin depuis le registre    
+        const entry = this.getEntry(name);
+        if (!entry) {
+            throw new Error(`RAG '${name}' n'existe pas`);
+        }
+        // if (status.status !== 'building') {
+        //   throw new Error(`RAG '${name}' n'est pas en construction (status: ${status.status})`);
+        // }
+        const buildPath = entry.configPath;
+        if (!(0, fs_1.existsSync)(buildPath)) {
+            throw new Error(`Le dossier de construction n'existe pas: ${buildPath}`);
+        }
+        const filePath = path_1.default.join(buildPath, filename);
+        const shaPath = path_1.default.join(buildPath, filename + '.sha');
+        // ✅ Sauvegarder le fichier
+        (0, fs_1.writeFileSync)(filePath, content, 'utf8');
+        // ✅ Sauvegarder le fingerprint
+        const sha = (0, usecase_1.calculateFingerprint)(content);
+        (0, fs_1.writeFileSync)(shaPath, sha, 'utf8');
+    }
+    /**
+     * Prépare un RAG enfant en copiant les documents d'un RAG parent
+     *
+     * Cette méthode fork un RAG existant en copiant tous ses documents:
+     * - `filename.md` - Fichier markdown original
+     * - `filename.md.sha` - Empreinte SHA du fichier original
+     * - `filename.enhanced.md` - Version enrichie (si disponible)
+     * - `filename.query.json` - Métadonnées et use cases (si disponible)
+     *
+     * Les fichiers d'index (vectors.dat, mapping.json, metadata.json) ne sont PAS copiés
+     * car ils seront reconstruits par build()
+     *
+     * @param fromRagName Nom du RAG parent
+     * @param toRagName Nom du RAG enfant (doit déjà exister via create())
+     * @param options Options de fork
+     * @returns Objet avec le nombre de documents et fichiers copiés
+     *
+     * @example
+     * ```typescript
+     * // Créer le RAG enfant
+     * await ragManager.create('rule-validation-1', 'PR validation');
+     *
+     * // Fork depuis le parent en excluant les fichiers modifiés
+     * const result = await ragManager.fork('rule-editor', 'rule-validation-1', {
+     *   exclude: ['modif-1.md', 'modif-2.md']
+     * });
+     * console.log(`✅ ${result.documents} documents copiés (${result.files} fichiers)`);
+     *
+     * // Ajouter les documents modifiés
+     * ragManager.addDocument('rule-validation-1', 'modif-1.md', newContent1);
+     * ragManager.addDocument('rule-validation-1', 'modif-2.md', newContent2);
+     *
+     * // Builder l'index
+     * await ragManager.build('rule-validation-1', allDocs);
+     * ```
+     */
+    fork(fromRagName, toRagName, options = {}) {
+        const excludes = options.exclude || [];
+        if (this.config.verbose) {
+            console.log(`🔄 Fork de '${fromRagName}' vers '${toRagName}' (${excludes.length} exclusions)`);
+        }
+        const result = this.addDocumentFrom(fromRagName, toRagName, excludes);
+        if (this.config.verbose) {
+            console.log(`✅ Fork terminé: ${result.documents} documents copiés (${result.files} fichiers)`);
+        }
+        return result;
+    }
+    /**
+     * [USAGE INTERNE] Copie tous les documents d'un RAG parent vers un RAG destination
+     *
+     * Cette méthode copie tous les fichiers associés aux documents indexés:
+     * - `filename.md` - Fichier markdown original
+     * - `filename.md.sha` - Empreinte SHA du fichier original
+     * - `filename.enhanced.md` - Version enrichie (si disponible)
+     * - `filename.query.json` - Métadonnées et use cases (si disponible)
+     *
+     * @private
+     * @param fromRagName Nom du RAG source
+     * @param toRagName Nom du RAG destination
+     * @param excludes Liste des fichiers à ne PAS copier (ex: ['procedure-1.md', 'procedure-2.md'])
+     * @returns Objet avec le nombre de documents copiés et le nombre de fichiers copiés
+     */
+    addDocumentFrom(fromRagName, toRagName, excludes = []) {
+        // Récupérer le RAG source
+        const source = this.getEntry(fromRagName);
+        if (!source) {
+            throw new Error(`RAG source '${fromRagName}' n'existe pas`);
+        }
+        // Vérifier que le RAG source est actif
+        if (source.status !== 'active') {
+            throw new Error(`RAG source '${fromRagName}' n'est pas actif (status: ${source.status})`);
+        }
+        // Récupérer le RAG destination
+        const dest = this.getEntry(toRagName);
+        if (!dest) {
+            throw new Error(`RAG destination '${toRagName}' n'existe pas`);
+        }
+        // Charger les métadonnées du parent pour obtenir la liste des documents
+        let parentMetadata;
+        try {
+            const parentEmbeddings = this.load(fromRagName);
+            parentMetadata = parentEmbeddings.getMetadata();
+        }
+        catch (error) {
+            throw new Error(`Impossible de charger les métadonnées du RAG '${fromRagName}': ${error}`);
+        }
+        // Créer un Set des fichiers à exclure (normaliser les noms)
+        const excludeSet = new Set(excludes.map(f => f.replace(/\.md$/, '')));
+        // Liste des extensions de fichiers à copier
+        const extensions = [
+            '.md', // Fichier original
+            '.md.sha', // Empreinte
+            '.enhanced.md', // Version enrichie
+            '.query.json' // Métadonnées et use cases
+        ];
+        let copiedDocuments = 0;
+        let copiedFiles = 0;
+        // Parcourir tous les documents dans les métadonnées
+        for (const docRef of Object.values(parentMetadata.documents)) {
+            const baseName = docRef.filename.replace(/\.md$/, '');
+            // Vérifier si ce document est dans la liste d'exclusion
+            if (excludeSet.has(baseName)) {
+                continue;
+            }
+            let documentCopied = false;
+            // Copier tous les fichiers existants pour ce document
+            for (const ext of extensions) {
+                const sourceFile = path_1.default.join(source.configPath, baseName + ext);
+                const destFile = path_1.default.join(dest.configPath, baseName + ext);
+                if ((0, fs_1.existsSync)(sourceFile)) {
+                    (0, fs_1.copyFileSync)(sourceFile, destFile);
+                    copiedFiles++;
+                    documentCopied = true;
+                }
+            }
+            if (documentCopied) {
+                copiedDocuments++;
+            }
+        }
+        // Note: Les fichiers d'index (vectors.dat, mapping.json, metadata.json) 
+        // ne sont PAS copiés car ils seront reconstruits par build()
+        return { documents: copiedDocuments, files: copiedFiles };
+    }
+    /**
+     * Compare le contenu d'un document avec celui stocké dans le RAG
+     *
+     * @param name Nom du RAG
+     * @param file Nom du fichier (ex: 'ppe-budget.md')
+     * @param content Contenu à comparer
+     * @returns true si identique, false sinon
+     */
+    documentEqual(name, file, content) {
+        const entry = this.getEntry(name);
+        if (!entry) {
+            throw new Error(`RAG '${name}' n'existe pas`);
+        }
+        const configPath = entry.configPath;
+        const mdPath = path_1.default.join(configPath, file);
+        const shaPath = path_1.default.join(configPath, file + '.sha');
+        // Vérifier si le fichier et son sha existent
+        if (!(0, fs_1.existsSync)(mdPath) || !(0, fs_1.existsSync)(shaPath)) {
+            return false; // Fichier n'existe pas encore
+        }
+        // Comparer les fingerprints
+        try {
+            const storedSha = (0, fs_1.readFileSync)(shaPath, 'utf8');
+            const newSha = (0, usecase_1.calculateFingerprint)(content);
+            return storedSha === newSha;
+        }
+        catch (error) {
+            return false; // Erreur de lecture = considérer comme différent
+        }
+    }
+    /**
+     * Charge les use cases d'un document depuis un RAG
+     *
+     * @param name Nom du RAG
+     * @param filename Nom du fichier de base (ex: 'procedure.md')
+     * @returns Les use cases du document
+     *
+     * @example
+     * ```typescript
+     * const queries = ragManager.loadUseCases('my-rag', 'procedure.md');
+     * console.log(`${queries.queries.length} use cases trouvés`);
+     * ```
+     */
+    loadUseCases(name, filename) {
+        const entry = this.getEntry(name);
+        if (!entry) {
+            throw new Error(`RAG '${name}' n'existe pas`);
+        }
+        const configPath = entry.configPath;
+        const baseName = filename.replace(/\.md$/, '');
+        const queryFile = baseName + '.query.json';
+        return (0, usecase_1.loadUseCases)(queryFile, { baseDir: configPath });
+    }
+    /**
+     * Construit un RAG de manière atomique
+     *
+     * Utilise le registre pour trouver le dossier de construction (configPath)
+     * et la destination finale (destDir)
+     *
+     * @param name Nom du RAG
+     * @param documents Documents parsés (optionnel, sinon charge depuis configPath)
+     * @param ragConfig Configuration optionnelle du RAG
+     */
+    async build(name, documents, ragConfig) {
+        let docs;
+        let isLegacyMode = false;
+        let entry;
+        let buildPath;
+        let destDir;
+        // Vérifier que le RAG existe
+        if (!this.exists(name)) {
+            throw new Error(`RAG '${name}' n'existe pas. Appelez d'abord create() ou create() avec fork.`);
+        }
+        entry = this.getEntry(name);
+        buildPath = entry.configPath;
+        destDir = entry.destDir;
+        // Déterminer le mode
+        if (documents) {
+            // ✅ Mode legacy : documents fournis
+            isLegacyMode = true;
+            docs = documents;
+            // Valider les documents
+            for (const document of docs) {
+                (0, types_1.isValidRAGMatter)(document.matter);
+            }
+        }
+        else {
+            // ✅ Mode normal : charger depuis le dossier
+            if (!(0, fs_1.existsSync)(buildPath)) {
+                throw new Error(`Le dossier de construction n'existe pas: ${buildPath}`);
+            }
+            // ✅ Charger les fichiers : .enhanced.md en priorité, sinon .md
+            docs = await this._loadDocumentsFromPath(buildPath);
+        }
+        console.log(`🔄 Construction du RAG: ${name}`);
+        // Marquer comme en construction
+        const registry = this.getRegistry();
+        entry.status = 'building';
+        this.cachedRegistry = { ...registry };
+        try {
+            // Configuration pour la construction
+            const buildConfig = {
+                baseDir: buildPath,
+                ...DEFAULT_RAG_CONFIG,
+                ...ragConfig
+            };
+            // Construire dans le dossier de construction
+            const embeddings = new embeddings_1.Embeddings(buildConfig);
+            // ✅ NOUVEAU : Récupérer le résultat de la construction
+            const buildResult = await embeddings.indexFromDocuments(docs);
+            console.log(`✅ Construction terminée dans: ${buildPath}`);
+            // ✅ NOUVEAU : Créer et sauvegarder les métadonnées
+            const metadata = {
+                version: buildResult.version,
+                tag: buildResult.tag,
+                createdAt: new Date().toISOString(),
+                config: buildConfig,
+                documents: buildResult.documents,
+                stats: {
+                    totalDocuments: docs.length,
+                    totalSections: buildResult.totalVectors,
+                    vectorDimensions: buildResult.vectorDimensions,
+                    indexSize: `${Math.round(buildResult.totalVectors * buildResult.vectorDimensions * 4 / 1024 / 1024)}MB`
+                },
+                files: {
+                    vectorsFile: types_1.RAG_FILES.VECTORS,
+                    mappingFile: types_1.RAG_FILES.MAPPING,
+                    queriesFile: types_1.RAG_FILES.QUERIES
+                }
+            };
+            //
+            // active the RAG after the build is successful
+            entry.status = 'active';
+            // Sauvegarder les métadonnées et le mapping
+            this.saveMetadata(buildPath, metadata);
+            this.saveMapping(buildPath, buildResult.mapping, buildResult);
+            // ✅ En mode legacy, on construit directement dans configPath (pas de déplacement)
+            if (!isLegacyMode && destDir) {
+                // Archiver l'ancienne version si elle existe
+                if ((0, fs_1.existsSync)(destDir)) {
+                    await this.archive(name);
+                }
+                // Basculement atomique: buildPath -> destDir
+                (0, fs_1.renameSync)(buildPath, destDir);
+                // Mettre à jour configPath avec destDir
+                entry.configPath = destDir;
+                delete entry.destDir;
+            }
+            // Marquer comme actif
+            entry.status = 'active';
+            this.cachedRegistry = { ...registry };
+            this.saveRegistry(registry);
+            console.log(`✅ RAG '${name}' construit avec succès`);
+            console.log(`   📁 configPath final: ${entry.configPath}`);
+            console.log(`   📦 Embeddings chargés en cache: ${this.loadedEmbeddings.size}`);
+            console.log(`   🔍 Embedding '${name}' dans le cache: ${this.loadedEmbeddings.has(name) ? 'OUI' : 'NON'}`);
+            // Notifier les embeddings chargés de se mettre à jour
+            this.notifyUpdate(name);
+        }
+        catch (error) {
+            // Nettoyer en cas d'erreur (seulement en mode legacy)
+            if (isLegacyMode && (0, fs_1.existsSync)(buildPath)) {
+                (0, fs_1.rmSync)(buildPath, { recursive: true, force: true });
+            }
+            entry.status = 'error';
+            this.cachedRegistry = { ...registry };
+            console.error(`❌ Erreur lors de la construction de '${name}':`, error);
+            throw error;
+        }
+    }
+    /**
+     * Charge tous les documents depuis un dossier
+     * Version interne qui prend un chemin direct
+     *
+     * @param baseDir Chemin du dossier
+     * @param endsWith Extension des fichiers à charger
+     * @returns Liste des documents parsés et validés
+     */
+    async _loadDocumentsFromPath(baseDir, endsWith) {
+        const docs = [];
+        if (endsWith) {
+            // ✅ Mode legacy : charger les fichiers avec une extension spécifique
+            const files = (0, fs_1.readdirSync)(baseDir).filter(f => f.endsWith(endsWith));
+            for (const file of files) {
+                try {
+                    const filePath = path_1.default.join(baseDir, file);
+                    const content = (0, fs_1.readFileSync)(filePath, 'utf8');
+                    // ✅ Utiliser le nom original (sans .enhanced) pour la référence
+                    const originalName = endsWith === '.enhanced.md'
+                        ? file.replace('.enhanced.md', '.md')
+                        : file;
+                    const parsedDoc = (0, parser_1.getSections)(content, originalName);
+                    // Valider le document
+                    (0, types_1.isValidRAGMatter)(parsedDoc.matter);
+                    docs.push(parsedDoc);
+                }
+                catch (error) {
+                    console.warn(`⚠️ Document invalide ignoré: ${file}`, error);
+                }
+            }
+        }
+        else {
+            // ✅ Mode intelligent : pour chaque .md, utiliser .enhanced.md s'il existe, sinon .md
+            const mdFiles = (0, fs_1.readdirSync)(baseDir)
+                .filter(f => f.endsWith('.md') && !f.endsWith('.enhanced.md'));
+            for (const mdFile of mdFiles) {
+                try {
+                    const baseName = mdFile.replace('.md', '');
+                    const enhancedPath = path_1.default.join(baseDir, baseName + '.enhanced.md');
+                    const mdPath = path_1.default.join(baseDir, mdFile);
+                    // Utiliser .enhanced.md en priorité, sinon .md
+                    const filePath = (0, fs_1.existsSync)(enhancedPath) ? enhancedPath : mdPath;
+                    const content = (0, fs_1.readFileSync)(filePath, 'utf8');
+                    const parsedDoc = (0, parser_1.getSections)(content, mdFile);
+                    // Valider le document
+                    (0, types_1.isValidRAGMatter)(parsedDoc.matter);
+                    docs.push(parsedDoc);
+                }
+                catch (error) {
+                    console.warn(`⚠️ Document invalide ignoré: ${mdFile}`, error);
+                }
+            }
+        }
+        if (docs.length === 0) {
+            throw new Error(`Aucun document valide trouvé dans ${baseDir}`);
+        }
+        return docs;
+    }
+    /**
+     * Charge tous les documents depuis un dossier du RAG
+     * Version publique qui utilise le nom du RAG
+     *
+     * @param name Nom du RAG
+     * @param endsWith Extension des fichiers à charger (par défaut '.enhanced.md')
+     * @returns Liste des documents parsés et validés
+     */
+    async loadDocumentsFromDir(name, endsWith = '.enhanced.md') {
+        const entry = this.getEntry(name);
+        if (!entry) {
+            throw new Error(`RAG '${name}' n'existe pas`);
+        }
+        return this._loadDocumentsFromPath(entry.configPath, endsWith);
+    }
+    /**
+     * Supprime un RAG du registre
+     */
+    async delete(name, archiveFlag = true) {
+        if (!this.exists(name)) {
+            throw new Error(`RAG '${name}' n'existe pas`);
+        }
+        const entry = this.getEntry(name);
+        const registry = this.getRegistry();
+        // Archiver si demandé
+        if (archiveFlag) {
+            await this.archive(name);
+        }
+        else if ((0, fs_1.existsSync)(entry.configPath)) {
+            (0, fs_1.rmSync)(entry.configPath, { recursive: true, force: true });
+        }
+        // Supprimer du registre
+        delete registry.registries[name];
+        // Supprimer de la map des embeddings chargés
+        this.loadedEmbeddings.delete(name);
+        // Changer le défaut si nécessaire
+        if (registry.defaultName === name) {
+            const remainingRAGs = Object.keys(registry.registries);
+            registry.defaultName = remainingRAGs.length > 0 ? remainingRAGs[0] : 'RAGRegistry';
+        }
+        this.saveRegistry(registry);
+        console.log(`✅ RAG supprimé: ${name}`);
+    }
+    /**
+     * Renomme un document dans un RAG existant
+     *
+     * Cette méthode renomme tous les fichiers associés à un document:
+     * - `oldFile.md` → `newFile.md`
+     * - `oldFile.md.sha` → `newFile.md.sha`
+     * - `oldFile.enhanced.md` → `newFile.enhanced.md`
+     * - `oldFile.query.json` → `newFile.query.json`
+     *
+     * Et met à jour les références dans les fichiers JSON (mapping, metadata, queries)
+     *
+     * @param ragName Nom du RAG concerné
+     * @param oldFile Ancien nom du fichier (ex: 'old-name.md')
+     * @param newFile Nouveau nom du fichier (ex: 'new-name.md')
+     *
+     * @example
+     * ```typescript
+     * ragManager.renameDocument('rule-validation-1', 'old-procedure.md', 'new-procedure.md');
+     * ```
+     */
+    renameDocument(ragName, oldFile, newFile) {
+        const entry = this.getEntry(ragName);
+        if (!entry) {
+            if (this.config.verbose) {
+                console.log(`⚠️ RAG '${ragName}' n'existe pas, skip rename document`);
+            }
+            return;
+        }
+        const configPath = entry.configPath;
+        //
+        // Liste des fichiers à renommer (sans extension pour le basename)
+        const oldBase = oldFile.replace(/\.md$/, '');
+        const newBase = newFile.replace(/\.md$/, '');
+        const filesToRename = [
+            { old: `${oldBase}.md`, new: `${newBase}.md` },
+            { old: `${oldBase}.md.sha`, new: `${newBase}.md.sha` },
+            { old: `${oldBase}.enhanced.md`, new: `${newBase}.enhanced.md` },
+            { old: `${oldBase}.query.json`, new: `${newBase}.query.json` }
+        ];
+        //
+        // Renommer les fichiers physiques
+        let renamedCount = 0;
+        for (const { old, new: newName } of filesToRename) {
+            const oldPath = path_1.default.join(configPath, old);
+            const newPath = path_1.default.join(configPath, newName);
+            if ((0, fs_1.existsSync)(oldPath)) {
+                try {
+                    (0, fs_1.renameSync)(oldPath, newPath);
+                    renamedCount++;
+                }
+                catch (error) {
+                    console.warn(`⚠️ Erreur renommage ${old} → ${newName}:`, error);
+                }
+            }
+        }
+        if (renamedCount === 0) {
+            if (this.config.verbose) {
+                console.log(`⚠️ Aucun fichier à renommer pour ${oldFile} dans RAG '${ragName}'`);
+            }
+            return;
+        }
+        //
+        // Mettre à jour les références dans les fichiers JSON
+        this.updateJSONReferences(configPath, oldFile, newFile);
+        if (this.config.verbose) {
+            console.log(`✅ Document renommé dans RAG '${ragName}': ${oldFile} → ${newFile} (${renamedCount} fichiers)`);
+        }
+        //
+        // Notifier les embeddings chargés de se mettre à jour avec l'action rename
+        this.notifyUpdate(ragName, {
+            action: 'rename',
+            oldFile,
+            newFile
+        });
+    }
+    /**
+     * Met à jour les références d'un fichier dans les JSON du RAG
+     *
+     * @param configPath Chemin du RAG
+     * @param oldFile Ancien nom du fichier
+     * @param newFile Nouveau nom du fichier
+     * @private
+     */
+    updateJSONReferences(configPath, oldFile, newFile) {
+        const metadataFile = path_1.default.join(configPath, types_1.RAG_FILES.METADATA);
+        const mappingFile = path_1.default.join(configPath, types_1.RAG_FILES.MAPPING);
+        //
+        // Mettre à jour metadata.json
+        if ((0, fs_1.existsSync)(metadataFile)) {
+            try {
+                const metadata = JSON.parse((0, fs_1.readFileSync)(metadataFile, 'utf8'));
+                //
+                // Mettre à jour les références dans documents
+                if (metadata.documents) {
+                    const docs = Object.entries(metadata.documents);
+                    for (const [key, doc] of docs) {
+                        if (doc.filename === oldFile) {
+                            doc.filename = newFile;
+                        }
+                        //
+                        // Mettre à jour aussi les références dans les sections
+                        if (key.startsWith(oldFile)) {
+                            const newKey = key.replace(oldFile, newFile);
+                            delete metadata.documents[key];
+                            metadata.documents[newKey] = doc;
+                        }
+                    }
+                }
+                (0, fs_1.writeFileSync)(metadataFile, JSON.stringify(metadata, null, 2), 'utf8');
+            }
+            catch (error) {
+                console.warn(`⚠️ Erreur mise à jour metadata.json:`, error);
+            }
+        }
+        //
+        // Mettre à jour mapping.json
+        if ((0, fs_1.existsSync)(mappingFile)) {
+            try {
+                const mappingData = JSON.parse((0, fs_1.readFileSync)(mappingFile, 'utf8'));
+                //
+                // Mettre à jour les clés du mapping
+                if (mappingData.mapping) {
+                    const entries = Object.entries(mappingData.mapping);
+                    for (const [id, ref] of entries) {
+                        if (ref.includes(oldFile)) {
+                            mappingData.mapping[id] = ref.replace(oldFile, newFile);
+                        }
+                    }
+                }
+                (0, fs_1.writeFileSync)(mappingFile, JSON.stringify(mappingData, null, 2), 'utf8');
+            }
+            catch (error) {
+                console.warn(`⚠️ Erreur mise à jour mapping.json:`, error);
+            }
+        }
+    }
+    /**
+     * Renomme un RAG existant
+     *
+     * @param from Nom actuel du RAG
+     * @param to Nouveau nom du RAG
+     * @param description Description optionnelle du RAG
+     * @throws Error si le nom est trop court, si une collision existe, ou si le RAG source n'existe pas
+     *
+     * @example
+     * ```typescript
+     * await ragManager.rename('old-name', 'new-name', 'Description mise à jour');
+     * ```
+     */
+    async rename(from, to, description) {
+        // Validation du nom de destination
+        const MIN_NAME_LENGTH = 3;
+        if (to.length < MIN_NAME_LENGTH) {
+            throw new Error(`Le nom '${to}' est trop court (minimum ${MIN_NAME_LENGTH} caractères)`);
+        }
+        // Vérifier que le RAG source existe
+        if (!this.exists(from)) {
+            throw new Error(`RAG source '${from}' n'existe pas`);
+        }
+        // Éviter les collisions
+        if (this.exists(to)) {
+            throw new Error(`RAG de destination '${to}' existe déjà - collision détectée`);
+        }
+        // Éviter les noms réservés
+        const reservedNames = ['temp', 'archives', 'registry', 'config'];
+        if (reservedNames.includes(to.toLowerCase())) {
+            throw new Error(`Le nom '${to}' est réservé et ne peut pas être utilisé`);
+        }
+        const sourceEntry = this.getEntry(from);
+        const sourcePath = sourceEntry.configPath;
+        const destPath = path_1.default.join(this.config.baseDir, to);
+        try {
+            // Renommer le dossier physique
+            if ((0, fs_1.existsSync)(sourcePath)) {
+                (0, fs_1.renameSync)(sourcePath, destPath);
+                if (this.config.verbose)
+                    console.log(`📁 Dossier renommé: ${sourcePath} → ${destPath}`);
+            }
+            // Mettre à jour le registre
+            const registry = this.getRegistry();
+            registry.registries[to] = {
+                name: to,
+                configPath: destPath,
+                status: sourceEntry.status,
+                description: description || sourceEntry.description
+            };
+            delete registry.registries[from];
+            // Mettre à jour le défaut si nécessaire
+            if (registry.defaultName === from) {
+                registry.defaultName = to;
+            }
+            // Mettre à jour la map des embeddings chargés
+            const embeddingData = this.loadedEmbeddings.get(from);
+            if (embeddingData) {
+                this.loadedEmbeddings.set(to, embeddingData);
+                this.loadedEmbeddings.delete(from);
+                // Notifier l'embedding de se mettre à jour avec le nouveau chemin
+                this.notifyUpdate(to);
+            }
+            // Mettre à jour le cache
+            this.saveRegistry(registry);
+            console.log(`✅ RAG renommé: ${from} → ${to}`);
+        }
+        catch (error) {
+            console.error(`❌ Erreur lors du renommage de '${from}' en '${to}':`, error);
+            throw new Error(`Impossible de renommer le RAG: ${error}`);
+        }
+    }
+    /**
+     * Met à jour le statut d'un RAG
+     *
+     * @param name Nom du RAG
+     * @param status Nouveau statut ('active' ou 'paused')
+     * @throws Error si le RAG n'existe pas ou si le statut est invalide
+     *
+     * @example
+     * ```typescript
+     * ragManager.updateStatus('knowledge', 'paused');
+     * ```
+     */
+    pause(name) {
+        if (!this.exists(name)) {
+            throw new Error(`RAG '${name}' n'existe pas`);
+        }
+        const entry = this.getEntry(name);
+        if (!entry) {
+            throw new Error(`Entrée RAG '${name}' non trouvée dans le registre`);
+        }
+        // FIXME missing test
+        if (entry.status !== 'active') {
+            throw new Error(`Impossible de mettre en pause '${name}' car il n'est pas actif`);
+        }
+        // Mettre à jour le statut
+        entry.status = 'paused';
+        // Notifier l'embedding de mettre à jour sont état
+        this.notifyUpdate(name);
+        // Sauvegarder le registre
+        const registry = this.getRegistry();
+        this.saveRegistry(registry);
+    }
+    unpause(name) {
+        if (!this.exists(name)) {
+            throw new Error(`RAG '${name}' n'existe pas`);
+        }
+        const entry = this.getEntry(name);
+        if (!entry) {
+            throw new Error(`Entrée RAG '${name}' non trouvée dans le registre`);
+        }
+        // Mettre à jour le statut
+        entry.status = 'active';
+        // Notifier l'embedding de mettre à jour sont état
+        this.notifyUpdate(name);
+        // Sauvegarder le registre
+        const registry = this.getRegistry();
+        this.saveRegistry(registry);
+    }
+    /**
+     * Nettoie les embeddings chargés obsolètes (plus vieux que maxAge)
+     * Utile pour libérer de la mémoire
+     *
+     * @param maxAge Âge maximum en millisecondes (défaut: 1 heure)
+     */
+    cleanDeadReferences(maxAge = 3600000) {
+        const now = Date.now();
+        const deadKeys = [];
+        for (const [name, data] of this.loadedEmbeddings.entries()) {
+            // Supprimer les embeddings trop vieux ou non valides
+            if (now - data.loadTime >= maxAge) {
+                deadKeys.push(name);
+            }
+        }
+        //
+        // remove embeddings from cached registry
+        for (const key of deadKeys) {
+            this.loadedEmbeddings.delete(key);
+        }
+        if (deadKeys.length > 0 && this.config.verbose) {
+            console.log(`🗑️ Nettoyage: ${deadKeys.length} embedding(s) obsolète(s) supprimé(s)`);
+        }
+    }
+    /**
+     * Obtient le nombre d'embeddings actuellement chargés
+     */
+    getLoadedCount() {
+        return this.loadedEmbeddings.size;
+    }
+    /**
+     * Charge un RAG par son nom et l'enregistre pour les updates réactifs
+     *
+     * Permet le chargement si:
+     * - Statut = 'active' : RAG complètement prêt
+     * - Statut = 'building' : RAG en construction mais déjà utilisable (recherche partielle)
+     */
+    load(name) {
+        if (!this.exists(name)) {
+            throw new Error(`RAG '${name}' n'existe pas`);
+        }
+        const entry = this.getEntry(name);
+        if (!entry) {
+            throw new Error(`RAG '${name}' n'existe pas`);
+        }
+        // Permettre le chargement si actif ou en cours de construction
+        if (entry.status !== 'active' && entry.status !== 'building') {
+            throw new Error(`RAG '${name}' n'est pas disponible (statut: ${entry.status})`);
+        }
+        //
+        // use cached embedding if available
+        const embeddingData = this.loadedEmbeddings.get(name);
+        if (embeddingData) {
+            return embeddingData.embedding;
+        }
+        // Vérifier que le dossier contient bien les fichiers nécessaires avant de charger
+        const metadataFile = path_1.default.join(entry.configPath, types_1.RAG_FILES.METADATA);
+        if (!(0, fs_1.existsSync)(metadataFile)) {
+            const statusMsg = entry.status === 'building'
+                ? `Le RAG '${name}' est en cours de construction. Les fichiers ne sont pas encore disponibles.`
+                : `Le RAG '${name}' est corrompu (fichier metadata manquant).`;
+            throw new Error(statusMsg);
+        }
+        // Charger la configuration depuis le fichier metadata
+        const ragConfig = this.loadConfig(entry.configPath);
+        // Instancier et vérifier l'Embeddings
+        const embeddings = new embeddings_1.Embeddings(ragConfig);
+        if (!embeddings.isReady()) {
+            throw new Error(`RAG '${name}' n'est pas prêt (fichiers manquants)`);
+        }
+        // Enregistrer l'embedding pour les updates réactifs
+        this.loadedEmbeddings.set(name, {
+            embedding: embeddings,
+            loadTime: Date.now()
+        });
+        if (this.config.verbose) {
+            const statusMsg = entry.status === 'building' ? '(en construction)' : '';
+            console.log(`✅ RAG chargé: ${name} ${statusMsg}`);
+        }
+        return embeddings;
+    }
+    /**
+     * Vérifie l'état d'un RAG
+     */
+    verify(name) {
+        if (!this.exists(name)) {
+            return false;
+        }
+        const entry = this.getEntry(name);
+        const registry = this.getRegistry();
+        // Vérifier que le dossier existe
+        if (!(0, fs_1.existsSync)(entry.configPath)) {
+            // Mettre à jour le statut
+            entry.status = 'error';
+            this.saveRegistry(registry);
+            return false;
+        }
+        try {
+            // Charger la configuration depuis le metadata
+            const ragConfig = this.loadConfig(entry.configPath);
+            const embeddingData = this.loadedEmbeddings.get(name);
+            const embeddings = (embeddingData) ? embeddingData.embedding : new embeddings_1.Embeddings(ragConfig);
+            const isReady = embeddings.isReady();
+            // Mettre à jour le statut (stateless - pas de sauvegarde automatique)
+            // Si le RAG est en "building", ne pas changer son statut
+            if (entry.status !== 'building') {
+                entry.status = isReady ? 'active' : 'error';
+            }
+            this.cachedRegistry = { ...registry };
+            // Un RAG en "building" est considéré comme valide (il existe)
+            return isReady || entry.status === 'building';
+        }
+        catch (error) {
+            // Erreur lors du chargement de la configuration
+            // Ne pas changer le statut si c'est "building"
+            if (entry.status !== 'building') {
+                entry.status = 'error';
+            }
+            this.cachedRegistry = { ...registry };
+            return entry.status === 'building'; // Un RAG en "building" est valide
+        }
+    }
+    /**
+     * Liste tous les RAG disponibles
+     */
+    list() {
+        const registry = this.getRegistry();
+        return Object.values(registry.registries) || [];
+    }
+    /**
+     * Obtient le statut d'un RAG
+     */
+    getStatus(name) {
+        if (!this.exists(name)) {
+            throw new Error(`RAG '${name}' n'existe pas`);
+        }
+        return this.getEntry(name);
+    }
+    /**
+     * Obtient la configuration d'un RAG depuis son metadata
+     */
+    getConfig(name) {
+        if (!this.exists(name)) {
+            throw new Error(`RAG '${name}' n'existe pas`);
+        }
+        const entry = this.getEntry(name);
+        try {
+            return this.loadConfig(entry.configPath);
+        }
+        catch (error) {
+            console.warn(`Erreur lors du chargement de la config pour '${name}':`, error);
+            throw error;
+        }
+    }
+    /**
+     * Définit le RAG par défaut
+     */
+    async setDefault(name) {
+        if (!this.exists(name)) {
+            throw new Error(`RAG '${name}' n'existe pas`);
+        }
+        const registry = this.getRegistry();
+        registry.defaultName = name;
+        this.saveRegistry(registry);
+        console.log(`✅ RAG par défaut défini: ${name}`);
+    }
+    /**
+     * Obtient le RAG par défaut
+     */
+    getDefault() {
+        const registry = this.getRegistry();
+        return registry.defaultName || 'RAGRegistry';
+    }
+    /**
+     * Obtient les statistiques de tous les RAG
+     */
+    getStats() {
+        const rags = this.list();
+        const stats = [];
+        for (const rag of rags) {
+            try {
+                const isValid = this.verify(rag.name);
+                let metadata = null;
+                if (isValid) {
+                    try {
+                        const embeddings = this.load(rag.name);
+                        metadata = embeddings.getMetadata();
+                    }
+                    catch (error) {
+                        // Si le chargement échoue, essayer d'obtenir au moins la config
+                        const config = this.getConfig(rag.name);
+                        if (config) {
+                            metadata = {
+                                stats: {
+                                    totalSections: 0,
+                                    vectorDimensions: config.dimensions || 1536,
+                                    indexSize: 'inconnu'
+                                }
+                            };
+                        }
+                    }
+                }
+                stats.push({
+                    name: rag.name,
+                    status: rag.status,
+                    isValid,
+                    configPath: rag.configPath,
+                    metadata: metadata ? {
+                        totalSections: metadata.stats?.totalSections || 0,
+                        vectorDimensions: metadata.stats?.vectorDimensions || 0,
+                        indexSize: metadata.stats?.indexSize || 'inconnu'
+                    } : null
+                });
+            }
+            catch (error) {
+                stats.push({
+                    name: rag.name,
+                    status: 'error',
+                    isValid: false,
+                    configPath: rag.configPath,
+                    error: error instanceof Error ? error.message : 'Erreur inconnue'
+                });
+            }
+        }
+        return stats;
+    }
+}
+exports.RAGManager = RAGManager;