agentic-api 1.0.6 → 2.0.31

package/dist/src/rag/lucene.js

@@ -0,0 +1,227 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LuceneManager = void 0;
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+// @ts-ignore - MiniSearch sera ajouté comme dépendance
+const minisearch_1 = __importDefault(require("minisearch"));
+// Import des stopwords français (devra être installé comme dépendance)
+let stopwordsFr = [];
+try {
+    // Fallback si le package n'est pas disponible
+    const sw = require('stopwords-fr');
+    stopwordsFr = sw.default || sw;
+}
+catch (error) {
+    // Liste réduite de stopwords français de base
+    stopwordsFr = [
+        'le', 'de', 'et', 'à', 'un', 'il', 'être', 'et', 'en', 'avoir', 'que', 'pour',
+        'dans', 'ce', 'son', 'une', 'sur', 'avec', 'ne', 'se', 'pas', 'tout', 'plus',
+        'par', 'grand', 'en', 'me', 'bien', 'elle', 'si', 'tout', 'son', 'nous', 'te',
+        'ou', 'mais', 'y', 'mon', 'lui', 'nous', 'comme', 'a', 'les', 'du', 'au', 'des'
+    ];
+}
+class LuceneManager {
+    constructor(config, baseDir) {
+        this.config = {
+            fields: ['query'],
+            storeFields: ['query', 'service', 'filename'],
+            ...config
+        };
+        this.indexFile = config.outputFile
+            ? path_1.default.join(baseDir, config.outputFile)
+            : path_1.default.join(baseDir, 'minisearch-queries.json');
+        this.miniSearch = new minisearch_1.default({
+            fields: this.config.fields,
+            storeFields: this.config.storeFields,
+            processTerm: this.processTerm.bind(this)
+        });
+        // Charger l'index existant si disponible
+        this.loadIndex();
+    }
+    /**
+     * Traitement des termes pour la recherche
+     */
+    processTerm(term) {
+        // Ignorer les stopwords et les termes trop courts
+        if (stopwordsFr.includes(term.toLowerCase()) || term.length <= 2) {
+            return null;
+        }
+        return term.toLowerCase();
+    }
+    /**
+     * Charge un index existant
+     */
+    loadIndex() {
+        if ((0, fs_1.existsSync)(this.indexFile)) {
+            try {
+                const indexData = JSON.parse((0, fs_1.readFileSync)(this.indexFile, 'utf8'));
+                this.miniSearch = minisearch_1.default.loadJSON(JSON.stringify(indexData), {
+                    fields: this.config.fields,
+                    storeFields: this.config.storeFields,
+                    processTerm: this.processTerm.bind(this)
+                });
+                console.log('Index Lucene chargé:', this.indexFile);
+            }
+            catch (error) {
+                console.error('Erreur lors du chargement de l\'index Lucene:', error);
+            }
+        }
+    }
+    /**
+     * Construit l'index Lucene à partir des fichiers de requêtes
+     */
+    async buildIndex(queriesDir) {
+        const queriesPath = queriesDir || this.config.queriesDir || './queries/';
+        if (!(0, fs_1.existsSync)(queriesPath)) {
+            throw new Error(`Répertoire des requêtes non trouvé: ${queriesPath}`);
+        }
+        // Lister tous les fichiers JSON dans le répertoire
+        const jsonFiles = (0, fs_1.readdirSync)(queriesPath)
+            .filter(file => file.endsWith('.json'))
+            .filter(file => !file.includes('unauthorized') && !file.startsWith('skip.'))
+            .map(file => path_1.default.join(queriesPath, file));
+        if (jsonFiles.length === 0) {
+            throw new Error(`Aucun fichier JSON trouvé dans: ${queriesPath}`);
+        }
+        let indexId = 1;
+        const documents = [];
+        const services = new Set();
+        for (const file of jsonFiles) {
+            const filename = path_1.default.basename(file, path_1.default.extname(file));
+            // Le service est décrit dans le nom du fichier (premier mot avant le premier "-")
+            const service = filename.split('-')[0];
+            services.add(service);
+            process.stdout.write(`Préparation index Lucene pour ${filename} : `);
+            try {
+                const content = JSON.parse((0, fs_1.readFileSync)(file, 'utf8'));
+                if (!Array.isArray(content) || content.length === 0) {
+                    console.log('❌ Aucune requête trouvée dans', file);
+                    continue;
+                }
+                for (const coverage of content) {
+                    if (coverage.question) {
+                        documents.push({
+                            id: (indexId++).toString(),
+                            query: coverage.question,
+                            service,
+                            filename
+                        });
+                        process.stdout.write('.');
+                    }
+                }
+                console.log(' ✅');
+            }
+            catch (error) {
+                console.log(`❌ Erreur lors de la lecture de ${file}:`, error);
+            }
+        }
+        if (documents.length === 0) {
+            throw new Error('Aucun document à indexer');
+        }
+        // Construire l'index
+        console.log(`Construction de l'index Lucene avec ${documents.length} documents...`);
+        this.miniSearch.addAll(documents);
+        // Sauvegarder l'index
+        this.saveIndex();
+        console.log(`Index Lucene créé avec succès: ${documents.length} requêtes, ${services.size} services`);
+        return;
+    }
+    /**
+     * Sauvegarde l'index
+     */
+    saveIndex() {
+        try {
+            const indexData = this.miniSearch.toJSON();
+            (0, fs_1.writeFileSync)(this.indexFile, JSON.stringify(indexData), { encoding: 'utf8', flag: 'w' });
+            console.log('Index Lucene sauvegardé:', this.indexFile);
+        }
+        catch (error) {
+            console.error('Erreur lors de la sauvegarde de l\'index Lucene:', error);
+        }
+    }
+    /**
+     * Recherche dans l'index Lucene
+     */
+    // search(query: string, options?: {
+    //   limit?: number;
+    //   fuzzy?: boolean | number;
+    //   prefix?: boolean;
+    //   filter?: (result: LuceneIndexDocument & { score: number }) => boolean;
+    // }): LuceneSearchResult {
+    //   const startTime = Date.now();
+    //   const searchOptions = {
+    //     fuzzy: options?.fuzzy ?? 0.2,
+    //     prefix: options?.prefix ?? true,
+    //     ...options
+    //   };
+    //   try {
+    //     const rawResults = this.miniSearch.search(query, searchOptions as any);
+    //     let results = rawResults.map((result: any) => ({
+    //       id: result.id,
+    //       query: result.query,
+    //       service: result.service,
+    //       filename: result.filename,
+    //       score: result.score
+    //     }));
+    //     // Appliquer un filtre personnalisé si fourni
+    //     if (options?.filter) {
+    //       results = results.filter(options.filter);
+    //     }
+    //     // Limiter les résultats
+    //     if (options?.limit) {
+    //       results = results.slice(0, options.limit);
+    //     }
+    //     return {
+    //       results,
+    //       searchTime: Date.now() - startTime
+    //     };
+    //   } catch (error) {
+    //     console.error('Erreur lors de la recherche Lucene:', error);
+    //     return {
+    //       results: [],
+    //       searchTime: Date.now() - startTime
+    //     };
+    //   }
+    // }
+    /**
+     * Obtient les statistiques de l'index
+     */
+    getStats() {
+        const documentCount = this.miniSearch.documentCount;
+        const services = new Set();
+        // Parcourir tous les documents pour compter les services
+        try {
+            // Note: MiniSearch ne fournit pas directement accès aux documents
+            // Cette méthode pourrait nécessiter une amélioration
+            const indexData = this.miniSearch.toJSON();
+            if (indexData && typeof indexData === 'object') {
+                // Estimation basée sur la taille de l'index sérialisé
+                const indexSizeKB = Math.round(JSON.stringify(indexData).length / 1024);
+                return {
+                    totalDocuments: documentCount,
+                    totalServices: services.size,
+                    indexSize: indexSizeKB > 1024 ? `${Math.round(indexSizeKB / 1024)}MB` : `${indexSizeKB}KB`
+                };
+            }
+        }
+        catch (error) {
+            console.error('Erreur lors du calcul des statistiques:', error);
+        }
+        return {
+            totalDocuments: documentCount,
+            totalServices: 0,
+            indexSize: 'inconnu'
+        };
+    }
+    /**
+     * Vérifie si l'index est prêt
+     */
+    isReady() {
+        return this.miniSearch.documentCount > 0;
+    }
+}
+exports.LuceneManager = LuceneManager;

package/dist/src/rag/parser.d.ts

@@ -0,0 +1,68 @@
+import { ParsedDocument, DocumentSection } from './types';
+/**
+ * Découpe le contenu d'un document en sections séparées par '---'
+ *
+ * @param content Contenu du document
+ * @param filename Nom du fichier (pour le titre par défaut)
+ * @returns Sections et header du document
+ */
+export declare function getSections(content: string, filename: string): ParsedDocument;
+/**
+ * Récupère une section spécifique d'un document à partir de son ID
+ *
+ * @param id - ID numérique du document dans l'index
+ * @param ids - Mapping des IDs vers les noms de fichiers avec références de sections
+ * @param prefix - Chemin de base vers les documents
+ * @returns Objet contenant la source, le titre et le contenu de la section
+ * @throws Error si l'ID de document est invalide ou si la section n'existe pas
+ */
+export declare const getDocumentBySection: (id: number, ids: any, prefix: string) => {
+    source: any;
+    content: string;
+    title?: undefined;
+} | {
+    source: any;
+    title: string | undefined;
+    content: DocumentSection;
+};
+/**
+ * Normalise un vecteur avec la norme L2
+ *
+ * @param vector Vecteur à normaliser
+ * @returns Vecteur normalisé
+ */
+export declare function l2Normalize(vector: number[]): number[];
+/**
+ * Génère un slug unique pour un fichier
+ *
+ * @param filename Nom du fichier
+ * @param sectionIndex Index de la section (optionnel)
+ * @returns Slug unique
+ */
+export declare function generateDocumentRef(filename: string, sectionIndex?: number): string;
+/**
+ * Parse une référence de document pour extraire le nom de fichier et l'index de section
+ *
+ * @param ref Référence du document (filename#section-X)
+ * @returns Nom de fichier et index de section
+ */
+export declare function parseDocumentRef(ref: string): {
+    filename: string;
+    sectionIndex?: number;
+};
+/**
+ * Nettoie un bloc Markdown : supprime les préfixes « Titre: » et « Section: »
+ * (placés en début de ligne, avec ou sans espaces avant/après les deux-points).
+ *
+ * @param input Texte brut à nettoyer
+ * @returns Texte sans les entités Titre: et Section:
+ */
+export declare function sectionParseValues(input: string): string;
+export declare function sectionParseKey(key: string, input: string): string | null;
+/**
+ * Supprime les blocs <thinking> du contenu généré par l'IA
+ *
+ * @param content Contenu markdown avec potentiels blocs <thinking>
+ * @returns Contenu nettoyé sans les blocs <thinking>
+ */
+export declare function removeThinkingBlocks(content: string): string;

package/dist/src/rag/parser.js

@@ -0,0 +1,192 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDocumentBySection = void 0;
+exports.getSections = getSections;
+exports.l2Normalize = l2Normalize;
+exports.generateDocumentRef = generateDocumentRef;
+exports.parseDocumentRef = parseDocumentRef;
+exports.sectionParseValues = sectionParseValues;
+exports.sectionParseKey = sectionParseKey;
+exports.removeThinkingBlocks = removeThinkingBlocks;
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const rules_1 = require("../rules");
+/**
+ * Découpe le contenu d'un document en sections séparées par '---'
+ *
+ * @param content Contenu du document
+ * @param filename Nom du fichier (pour le titre par défaut)
+ * @returns Sections et header du document
+ */
+function getSections(content, filename) {
+    // IMPORTANT: Cette fonction traite les fichiers transformés par RAGGenerator 
+    // qui utilisent le format "Titre: ..." et "Section: ..." délimité par "---"
+    // Vérifier si le contenu contient un front-matter, 
+    // celui-ci contient le nom du fichier d'origine et le nom du service!
+    let { matter, content: contentWithoutMatter } = (0, rules_1.matterParse)(content);
+    // imprimer une alarm
+    if (matter?.mergeBase && matter?.createdBy) {
+        console.log('🔔 No standard matter found in file:', matter);
+    }
+    // S'assurer que matter contient au minimum filename et title
+    matter = {
+        ...matter,
+        filename,
+        title: matter.title || filename // Utiliser le filename comme titre par défaut
+    };
+    content = contentWithoutMatter || content;
+    //
+    // le contenu est toujours sans le front-matter!
+    const rawSections = content.split('---').map(section => section.trim());
+    if (!rawSections.length) {
+        return {
+            filename,
+            sections: [],
+            content,
+            matter
+        };
+    }
+    // Transformer les sections brutes en DocumentSection
+    const sections = rawSections
+        .map((content, index) => ({
+        content: content.trim(),
+        index,
+        lines: content.split('\n').length,
+        title: sectionParseKey('titre', content) || undefined
+    }))
+        .filter(section => section.lines > 2); // Filtrer les sections trop courtes
+    //
+    // le matter contient les informations du fichier d'origine! (service, responssable, fichier, etc.)
+    return {
+        filename,
+        sections,
+        content,
+        matter
+    };
+}
+/**
+ * Récupère une section spécifique d'un document à partir de son ID
+ *
+ * @param id - ID numérique du document dans l'index
+ * @param ids - Mapping des IDs vers les noms de fichiers avec références de sections
+ * @param prefix - Chemin de base vers les documents
+ * @returns Objet contenant la source, le titre et le contenu de la section
+ * @throws Error si l'ID de document est invalide ou si la section n'existe pas
+ */
+const getDocumentBySection = (id, ids, prefix) => {
+    const fullname = ids[id + ''];
+    const [filename, ref] = fullname?.split('#') || [];
+    if (!filename) {
+        console.log('❌❌ Invalid document id :' + fullname, id);
+        throw new Error('Invalid document id :' + fullname);
+    }
+    const content = (0, fs_1.readFileSync)(path_1.default.join(prefix, filename), 'utf8');
+    const { sections } = getSections(content, filename);
+    if (!sections.length) {
+        return {
+            source: fullname,
+            content: 'Le document n\'est plus disponible'
+        };
+    }
+    // Parse number of 'section-123'
+    const sectionNumber = parseInt(ref.match(/\d+/)[0]);
+    const section = sections[sectionNumber];
+    // console.log('--- DBG getDocument : section', sectionNumber, section?.length);
+    return {
+        source: fullname,
+        title: section.title,
+        content: section
+    };
+};
+exports.getDocumentBySection = getDocumentBySection;
+// extractSectionTitle supprimée - remplacée par sectionParseKey('titre', content)
+/**
+ * Normalise un vecteur avec la norme L2
+ *
+ * @param vector Vecteur à normaliser
+ * @returns Vecteur normalisé
+ */
+function l2Normalize(vector) {
+    const norm = Math.sqrt(vector.reduce((sum, val) => sum + val * val, 0));
+    return vector.map(val => val / norm);
+}
+/**
+ * Génère un slug unique pour un fichier
+ *
+ * @param filename Nom du fichier
+ * @param sectionIndex Index de la section (optionnel)
+ * @returns Slug unique
+ */
+function generateDocumentRef(filename, sectionIndex) {
+    const baseRef = filename.replace(/\.[^/.]+$/, ''); // Retirer l'extension
+    return sectionIndex !== undefined ? `${baseRef}#section-${sectionIndex}` : baseRef;
+}
+/**
+ * Parse une référence de document pour extraire le nom de fichier et l'index de section
+ *
+ * @param ref Référence du document (filename#section-X)
+ * @returns Nom de fichier et index de section
+ */
+function parseDocumentRef(ref) {
+    const [filename, sectionPart] = ref.split('#');
+    if (!sectionPart) {
+        return { filename };
+    }
+    const match = sectionPart.match(/section-(\d+)/);
+    if (match) {
+        return { filename, sectionIndex: parseInt(match[1]) };
+    }
+    return { filename };
+}
+/**
+ * Nettoie un bloc Markdown : supprime les préfixes « Titre: » et « Section: »
+ * (placés en début de ligne, avec ou sans espaces avant/après les deux-points).
+ *
+ * @param input Texte brut à nettoyer
+ * @returns Texte sans les entités Titre: et Section:
+ */
+function sectionParseValues(input) {
+    return input
+        // 1. Retirer les lignes vides en tête pour éviter des espaces résiduels
+        .replace(/^\s*\n/, '')
+        // 2. Supprimer « Titre: » ou « Section: » exclusivement en début de ligne
+        .replace(/^\s*(Titre|Section)\s*:\s*/gim, '')
+        // 3. Supprimer les espaces superflus qui pourraient rester
+        .trim();
+}
+function sectionParseKey(key, input) {
+    // Normaliser la clé recherchée en minuscules
+    const normalizedKey = key.toLowerCase().trim();
+    // Diviser le texte en lignes
+    const lines = input.split('\n');
+    // Chercher la ligne qui commence par la clé (case-insensitive)
+    for (const line of lines) {
+        const trimmedLine = line.trim();
+        // Vérifier si la ligne contient un ':'
+        if (trimmedLine.includes(':')) {
+            const [lineKey, ...valueParts] = trimmedLine.split(':');
+            const normalizedLineKey = lineKey.trim().toLowerCase();
+            // Comparer les clés en mode case-insensitive
+            if (normalizedLineKey === normalizedKey) {
+                const value = valueParts.join(':').trim();
+                // Retourner la valeur, même si elle est vide
+                return value;
+            }
+        }
+    }
+    // Si la clé n'est pas trouvée, lever une exception
+    // throw new Error(`Clé "${key}" non trouvée dans la section`);
+    return null;
+}
+/**
+ * Supprime les blocs <thinking> du contenu généré par l'IA
+ *
+ * @param content Contenu markdown avec potentiels blocs <thinking>
+ * @returns Contenu nettoyé sans les blocs <thinking>
+ */
+function removeThinkingBlocks(content) {
+    return content.replace(/<thinking>[\s\S]*?<\/thinking>/g, '').trim();
+}

package/dist/src/rag/tools.d.ts

@@ -0,0 +1,76 @@
+import OpenAI from 'openai';
+import { RAGConfig } from './types';
+/**
+ * Crée les outils RAG pour un agent
+ */
+declare const createTools: (openai: OpenAI, config: RAGConfig) => {
+    toolsReferencesContent: {
+        type: "function";
+        function: {
+            name: string;
+            description: string;
+            parameters: {
+                type: string;
+                properties: {
+                    service: {
+                        type: string;
+                        description: string;
+                    };
+                    source: {
+                        type: string;
+                        description: string;
+                    };
+                };
+                required: never[];
+                additionalProperties: boolean;
+            };
+        };
+    };
+    toolsKnowledge: {
+        type: "function";
+        function: {
+            name: string;
+            description: string;
+            parameters: {
+                type: string;
+                properties: {
+                    question: {
+                        type: string;
+                        description: string;
+                    };
+                    justification: {
+                        type: string;
+                        description: string;
+                    };
+                    action_suivante: {
+                        type: string;
+                        description: string;
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+        };
+    };
+    lookupReferencesContent: ({ service, source }: {
+        service?: string;
+        source?: string;
+    }) => Promise<{
+        content: string;
+    }>;
+    lookupKnowledge: (args: any, debug?: boolean) => Promise<{
+        content: string;
+        documents?: undefined;
+        scores?: undefined;
+    } | {
+        documents: {
+            id: number;
+            ref: string;
+            score: number;
+            content: string;
+        }[];
+        scores: number[];
+        content?: undefined;
+    }>;
+};
+export { createTools };