agentic-api 1.0.5 → 2.0.26

package/dist/src/rag/tools.js

@@ -0,0 +1,196 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTools = void 0;
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const parser_1 = require("./parser");
+const embeddings_1 = require("./embeddings");
+/**
+ * Prompts de suivi pour les outils
+ */
+const lookupReferencesContentFollowUpPrompt = "📋 RÉFÉRENCES DISPONIBLES\n\n";
+const lookupKnowledgeFollowUpPrompt = "🔍 RECHERCHE DANS LA BASE DE CONNAISSANCES\n\n";
+/**
+ * Définitions des outils pour l'agent
+ */
+const toolsReferencesContent = {
+    type: "function",
+    function: {
+        name: "lookupReferencesContent",
+        description: "Récupère le contenu d'un document spécifique ou liste tous les documents disponibles, optionnellement filtrés par service.",
+        parameters: {
+            type: "object",
+            properties: {
+                service: {
+                    type: "string",
+                    description: "Nom du service optionnel (ex: 'Gérance', 'PPE', 'Comptabilité') pour filtrer les documents (insensible à la casse)."
+                },
+                source: {
+                    type: "string",
+                    description: "Identifiant source optionnel (généralement un nom de fichier sans extension) pour récupérer le contenu d'un document spécifique."
+                }
+            },
+            required: [],
+            additionalProperties: false
+        }
+    }
+};
+const toolsKnowledge = {
+    type: "function",
+    function: {
+        name: "lookupKnowledge",
+        description: "Effectue une recherche de connaissances en utilisant la recherche vectorielle basée sur la question de l'utilisateur.",
+        parameters: {
+            type: "object",
+            properties: {
+                question: {
+                    type: "string",
+                    description: "La question de l'utilisateur à rechercher."
+                },
+                justification: {
+                    type: "string",
+                    description: "Justification optionnelle pour la recherche (actuellement loggée mais non utilisée dans la logique principale)."
+                },
+                action_suivante: {
+                    type: "string",
+                    description: "Action suivante optionnelle pour instruire le LLM après traitement des résultats."
+                }
+            },
+            required: ["question"],
+            additionalProperties: false
+        }
+    }
+};
+/**
+ * Extrait le header d'un fichier
+ */
+function getMatterHeaderFromFile(filePath) {
+    try {
+        const content = (0, fs_1.readFileSync)(filePath, 'utf8');
+        const { sections } = (0, parser_1.getSections)(content, path_1.default.basename(filePath));
+        // Essayer d'extraire le titre de la première section
+        const firstSection = sections[0];
+        if (firstSection?.title) {
+            return { title: firstSection.title };
+        }
+        // Fallback sur le nom du fichier
+        const filename = path_1.default.basename(filePath, path_1.default.extname(filePath));
+        return { title: filename.replace(/-/g, ' ') };
+    }
+    catch (error) {
+        const filename = path_1.default.basename(filePath, path_1.default.extname(filePath));
+        return { title: filename.replace(/-/g, ' ') };
+    }
+}
+// getDocumentFromId supprimée - utilisation directe de semanticSearch
+/**
+ * Crée les outils RAG pour un agent
+ */
+const createTools = (openai, config) => {
+    // Utiliser l'API Embeddings existante
+    const embeddings = new embeddings_1.Embeddings(config);
+    if (!embeddings.isReady()) {
+        throw new Error(`Index RAG non disponible à ${config.baseDir}. Exécutez buildrag d'abord.`);
+    }
+    // Charger le mapping des IDs
+    const mappingFile = path_1.default.join(config.baseDir, 'rag-mapping.json');
+    let ids = {};
+    try {
+        const mappingData = (0, fs_1.readFileSync)(mappingFile, 'utf8');
+        const mapping = JSON.parse(mappingData);
+        ids = mapping.mapping;
+    }
+    catch (error) {
+        console.error('Erreur lors du chargement du mapping:', error);
+        throw new Error('Mapping RAG non disponible');
+    }
+    /**
+     * Récupère le contenu d'un document spécifique ou liste tous les documents disponibles,
+     * optionnellement filtrés par service.
+     */
+    const lookupReferencesContent = async ({ service, source }) => {
+        const documentPath = config.baseDir;
+        const ftService = service?.toLowerCase();
+        // Liste tous les fichiers markdown dans le répertoire spécifié
+        const mdfiles = (0, fs_1.readdirSync)(documentPath)
+            .filter((file) => file.endsWith('.md') &&
+            (!ftService || file.toLowerCase().includes(ftService)))
+            .map((file) => path_1.default.join(documentPath, file));
+        // Si un source spécifique a été demandé
+        if (source) {
+            source = source.replace(/\.md.*/, '');
+            const file = mdfiles.find((file) => file.includes(source));
+            if (!file) {
+                return { content: `Désolé, je n'ai pas trouvé le document "${source}".` };
+            }
+            const filename = path_1.default.basename(file);
+            const content = (0, fs_1.readFileSync)(file, 'utf8');
+            const { sections } = (0, parser_1.getSections)(content, filename);
+            if (sections.length > 0) {
+                const title = sections[0].title || filename;
+                const allContent = sections.map(s => s.content).join('\n\n');
+                const response = `${title}\n\n${allContent}\n\n[»](${filename})`;
+                return { content: response };
+            }
+            else {
+                return { content: `Le document "${source}" est vide ou mal formaté.` };
+            }
+        }
+        // Si aucun source spécifié, lister les documents (filtrés par service si applicable)
+        const serviceTitle = ftService ? ` pour le service "${service}"` : '';
+        if (!mdfiles.length) {
+            return { content: `Désolé, aucun document trouvé${serviceTitle}.` };
+        }
+        const title = `${lookupReferencesContentFollowUpPrompt}Voici la liste exhaustive des documents disponibles${serviceTitle} :\n`;
+        const content = title + mdfiles.reduce((acc, file) => {
+            const header = getMatterHeaderFromFile(file);
+            const filename = path_1.default.basename(file);
+            return acc + `- ${header.title} [»](/${filename})\n`;
+        }, '');
+        return { content };
+    };
+    /**
+     * Effectue une recherche de connaissances en utilisant la recherche vectorielle
+     */
+    const lookupKnowledge = async (args, debug = false) => {
+        console.log("lookupKnowledge", args.question);
+        try {
+            // Utiliser l'API de recherche sémantique existante
+            const result = await embeddings.semanticSearch(args.question, {
+                neighbors: 5,
+                debug
+            });
+            if (!result.results || !result.results.length) {
+                return {
+                    content: `Aucun document relatif à cette question.(⚠️ Tu dois continuer ton plan sans cette information)`
+                };
+            }
+            console.log(`--- DBG rag search: ${result.results.length} documents trouvés`);
+            if (debug) {
+                return {
+                    documents: result.results,
+                    scores: result.results.map(r => r.score)
+                };
+            }
+            const action_suivante = args.action_suivante || "";
+            const withNextAction = action_suivante ?
+                `(⚠️ A la fin de cette tâche, tu dois exécuter l'action suivante: "${action_suivante}")` : "";
+            const prefix = `${lookupKnowledgeFollowUpPrompt}Voici les sections des documents (avec les références) à analyser de manière exhaustive.${withNextAction}:\n`;
+            const response = prefix + result.results.reduce((doc, curr) => {
+                return doc + `\n---\n[${curr.content}](/${curr.ref})`;
+            }, '');
+            return { content: response };
+        }
+        catch (error) {
+            console.error('Erreur lors de la recherche:', error);
+            return {
+                content: `Erreur lors de la recherche dans la base de connaissances. (⚠️ Tu dois continuer ton plan sans cette information)`
+            };
+        }
+    };
+    return { toolsReferencesContent, toolsKnowledge, lookupReferencesContent, lookupKnowledge };
+};
+exports.createTools = createTools;

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

@@ -0,0 +1,178 @@
+export declare const RAG_FILES: {
+    readonly VECTORS: "rag-hnsw.dat";
+    readonly METADATA: "rag-metadata.json";
+    readonly MAPPING: "rag-mapping.json";
+    readonly QUERIES: "rag-queries.json";
+};
+export interface RAGConfig {
+    /** Répertoire de base pour les documents et index */
+    baseDir: string;
+    /** Nom du fichier de vecteurs (sans extension) */
+    vectorsFile?: string;
+    /** Dimensions des vecteurs d'embedding */
+    dimensions?: number;
+    /** Distance utilisée pour l'index (cosine, l2, ip) */
+    distance?: 'cosine' | 'l2' | 'ip';
+    /** Configuration pour l'index HierarchicalNSW */
+    hnswConfig?: {
+        ef?: number;
+        m?: number;
+    };
+    /** Filtrer les fichiers d'entrée par préfixe */
+    filterInput?: string;
+    /** Préfixe pour tous les fichiers RAG */
+    prefix?: string;
+    /** Version du RAG (format X.Y) */
+    version?: string;
+    /** Tag de version (format vYYYYMMDD) */
+    tag?: string;
+    /** ID de départ pour l'indexation */
+    startId?: number;
+    /** Intégration avec RulesWorkflow */
+    useRulesWorkflow?: boolean;
+    /** Mode en mémoire pour les tests unitaires */
+    inmemory?: boolean;
+}
+export interface RAGMetadata {
+    /** Version du format des métadonnées */
+    version: string;
+    /** Tag de version (vYYYYMMDD) */
+    tag: string;
+    /** Timestamp de création */
+    createdAt: string;
+    /** Configuration utilisée pour créer l'index */
+    config: RAGConfig;
+    /** Mapping ID → référence document/section */
+    documents: Record<string, DocumentReference>;
+    /**
+     * Dernier identifiant documentaire attribué.
+     * Utilisé pour générer un ID documentaire stable (matter.id) indépendant du nom de fichier.
+     */
+    docLastID?: number;
+    /** Checkpoint avec le hash du dernier commit de la branche */
+    checkpoint: {
+        branch: string;
+        hash: string;
+    };
+    /** Statistiques de l'index */
+    stats: {
+        totalDocuments: number;
+        totalSections: number;
+        vectorDimensions: number;
+        indexSize: string;
+    };
+    /** Fichiers RAG associés */
+    files: {
+        /** Fichier d'index vectoriel */
+        vectorsFile: string;
+        /** Fichier de mapping des IDs */
+        mappingFile: string;
+        /** Fichier des use cases/queries */
+        queriesFile: string;
+    };
+}
+export interface DocumentReference {
+    /** Nom du fichier source */
+    filename: string;
+    /** Index de la section dans le document */
+    sectionIndex: number;
+    /** Référence complète (filename#section-X) */
+    ref: string;
+    /** Titre de la section */
+    title?: string;
+    /** Contenu de la section */
+    content: string;
+    /** Métadonnées du document */
+    metadata?: Record<string, any>;
+}
+export interface DocumentSection {
+    /** Contenu de la section */
+    content: string;
+    /** Numéro de la section */
+    index: number;
+    /** Titre de la section */
+    title?: string;
+    /** Longueur en lignes */
+    lines: number;
+}
+export interface ParsedDocument {
+    /** Nom du fichier source dans GIT*/
+    filename: string;
+    /** Métadonnées du front-matter */
+    matter: Record<string, any>;
+    /** Contenu sans le front-matter */
+    content: string;
+    /** Sections du document */
+    sections: DocumentSection[];
+}
+export interface RAGRef {
+    /** ID du document */
+    id: number;
+    /** Référence (filename#section-X) */
+    ref: string;
+    /** Score de similarité */
+    score: number;
+    /** Contenu de la section */
+    content: string;
+}
+export interface RAGSearchResult {
+    /** Résultats de la recherche */
+    results: RAGRef[];
+    /** Temps de recherche en ms */
+    searchTime?: number;
+}
+export interface EmbeddingResult {
+    /** ID attribué */
+    id: number;
+    /** Référence (filename#section-X) */
+    ref: string;
+    /** Vecteur d'embedding */
+    vector: number[];
+}
+/** Interface pour les use cases extraits par GPT d'une section */
+export interface UserQuery {
+    /** Question utilisateur */
+    question: string;
+    /** Réponse attendue */
+    answer: string;
+    /** Nom du fichier source */
+    filename: string;
+    /** Index de la section */
+    sectionIndex: number;
+    /** Référence de la section (filename#section-X) */
+    ref: string;
+}
+/** Interface pour les use cases d'un document */
+export interface DocumentQueries {
+    /** Type de queries */
+    type: 'use-cases';
+    /** Version du fichier de queries */
+    version: string;
+    /** Tag de version */
+    tag: string;
+    /** Nom du fichier source */
+    source: string;
+    /** Nom du fichier */
+    file: string;
+    /** Liste des questions/réponses par section */
+    queries: UserQuery[];
+    /** Coût de l'extraction */
+    cost: number;
+}
+/** Interface pour le fichier de mapping des IDs */
+export interface RAGMapping {
+    /** Type de queries */
+    type: 'mapping';
+    /** Version du mapping */
+    version: string;
+    /** Tag de version */
+    tag: string;
+    /** Mapping ID → référence */
+    mapping: Record<string, string>;
+    /** Timestamp de création */
+    createdAt: string;
+}
+/**
+ * Génère un tag de version au format vYYYYMMDD
+ */
+export declare function generateVersionTag(): string;

package/dist/src/rag/types.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RAG_FILES = void 0;
+exports.generateVersionTag = generateVersionTag;
+// Constantes pour les noms de fichiers RAG
+exports.RAG_FILES = {
+    VECTORS: 'rag-hnsw.dat',
+    METADATA: 'rag-metadata.json',
+    MAPPING: 'rag-mapping.json',
+    QUERIES: 'rag-queries.json'
+};
+/**
+ * Génère un tag de version au format vYYYYMMDD
+ */
+function generateVersionTag() {
+    const today = new Date();
+    const year = today.getFullYear();
+    const month = String(today.getMonth() + 1).padStart(2, '0');
+    const day = String(today.getDate()).padStart(2, '0');
+    return `v${year}${month}${day}`;
+}

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

@@ -0,0 +1,16 @@
+import { DocumentQueries, UserQuery, RAGConfig, ParsedDocument } from './types';
+/**
+ * Extrait tous les use cases d'un document parsé
+ */
+export declare function extractDocumentUseCases(parsedDocument: ParsedDocument): Promise<{
+    queries: UserQuery[];
+    cost: number;
+}>;
+/**
+ * Sauvegarde les use cases dans un fichier JSON
+ */
+export declare function saveUseCases(queries: DocumentQueries, config: RAGConfig): void;
+/**
+ * Charge les use cases depuis un fichier JSON
+ */
+export declare function loadUseCases(file: string, config: RAGConfig): DocumentQueries;

package/dist/src/rag/usecase.js

@@ -0,0 +1,79 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractDocumentUseCases = extractDocumentUseCases;
+exports.saveUseCases = saveUseCases;
+exports.loadUseCases = loadUseCases;
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const usecase_1 = require("../usecase");
+/**
+ * Extrait tous les use cases d'un document parsé
+ */
+async function extractDocumentUseCases(parsedDocument) {
+    const { sections, filename } = parsedDocument;
+    if (!sections.length) {
+        console.log(`❌ Aucune section trouvée dans ${filename}`);
+        return { queries: [], cost: 0 };
+    }
+    let totalCost = 0;
+    const allQueries = [];
+    for (let index = 0; index < sections.length; index++) {
+        const section = sections[index];
+        if (section.content.split('\n').length <= 2) {
+            continue;
+        }
+        try {
+            const { json, cost } = await (0, usecase_1.callGPTToExtractUserQueries)(section.content, filename);
+            const result = JSON.parse(json);
+            if (result.queries && Array.isArray(result.queries)) {
+                // Enrichir chaque query avec les informations de section
+                const enrichedQueries = result.queries.map((query) => ({
+                    ...query,
+                    filename: path_1.default.basename(filename, path_1.default.extname(filename)),
+                    sectionIndex: index,
+                    ref: `${path_1.default.basename(filename, path_1.default.extname(filename))}#section-${index}`
+                }));
+                allQueries.push(...enrichedQueries);
+            }
+            totalCost += cost;
+        }
+        catch (error) {
+            console.error(`Erreur lors de l'extraction des use cases pour ${filename}, section ${index}:`, error);
+        }
+    }
+    return { queries: allQueries, cost: totalCost };
+}
+/**
+ * Sauvegarde les use cases dans un fichier JSON
+ */
+function saveUseCases(queries, config) {
+    try {
+        const file = path_1.default.join(config.baseDir, queries.file);
+        (0, fs_1.writeFileSync)(file, JSON.stringify(queries, null, 2), 'utf8');
+        console.log(`🔔 Use cases sauvegardés: ${file}`);
+    }
+    catch (error) {
+        console.error('Erreur lors de la sauvegarde des use cases:', error);
+        throw new Error(`Erreur lors de la sauvegarde des use cases: ${error.message}`);
+    }
+}
+/**
+ * Charge les use cases depuis un fichier JSON
+ */
+function loadUseCases(file, config) {
+    const queriesFile = path_1.default.join(config.baseDir, file);
+    if (!(0, fs_1.existsSync)(queriesFile)) {
+        console.log(`🔔 Aucun fichier de use cases trouvé: ${queriesFile}`);
+        throw new Error(`Aucun fichier de use cases trouvé: ${queriesFile}`);
+    }
+    try {
+        return JSON.parse((0, fs_1.readFileSync)(queriesFile, 'utf8'));
+    }
+    catch (error) {
+        console.error('🔔 Erreur lors du chargement des use cases:', error);
+        throw new Error(`Erreur lors du chargement des use cases: ${queriesFile} ${error.message}`);
+    }
+}

package/dist/src/rules/errors.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Erreur de base pour toutes les opérations Git
+ */
+export declare class GitOperationError extends Error {
+    readonly operation: string;
+    readonly details?: any | undefined;
+    constructor(message: string, operation: string, details?: any | undefined);
+}
+/**
+ * Erreur de configuration Git manquante ou invalide
+ */
+export declare class GitConfigurationError extends GitOperationError {
+    constructor(message: string, missingConfig?: string);
+}
+/**
+ * Erreur quand un fichier demandé n'existe pas
+ */
+export declare class FileNotFoundError extends GitOperationError {
+    readonly filePath: string;
+    readonly branch: string;
+    constructor(filePath: string, branch: string);
+}
+/**
+ * Erreur quand une branche demandée n'existe pas
+ */
+export declare class BranchNotFoundError extends GitOperationError {
+    readonly branch: string;
+    constructor(branch: string);
+}
+/**
+ * Erreur lors de la création d'un PR (conflit, branche existante, etc.)
+ */
+export declare class PRCreationError extends GitOperationError {
+    readonly attemptedBranch?: string | undefined;
+    readonly conflictingFiles?: string[] | undefined;
+    constructor(message: string, attemptedBranch?: string | undefined, conflictingFiles?: string[] | undefined);
+}
+/**
+ * Erreur lors des opérations de fermeture de PR
+ */
+export declare class PRClosureError extends GitOperationError {
+    readonly prBranch: string;
+    readonly reason?: string | undefined;
+    constructor(message: string, prBranch: string, reason?: string | undefined);
+}
+/**
+ * Erreur de concurrence lors de l'allocation de numéros de PR
+ */
+export declare class ConcurrencyError extends GitOperationError {
+    readonly resourceType: string;
+    readonly retryCount?: number | undefined;
+    constructor(message: string, resourceType: string, retryCount?: number | undefined);
+}
+/**
+ * Error thrown when a Git tag creation operation fails.
+ */
+export declare class TagCreationError extends GitOperationError {
+    tagName: string;
+    constructor(tagName: string, message: string, details?: any);
+}

package/dist/src/rules/errors.js

@@ -0,0 +1,97 @@
+"use strict";
+// ===== CLASSES D'ERREUR TYPÉES =====
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TagCreationError = exports.ConcurrencyError = exports.PRClosureError = exports.PRCreationError = exports.BranchNotFoundError = exports.FileNotFoundError = exports.GitConfigurationError = exports.GitOperationError = void 0;
+/**
+ * Erreur de base pour toutes les opérations Git
+ */
+class GitOperationError extends Error {
+    constructor(message, operation, details) {
+        super(message);
+        this.operation = operation;
+        this.details = details;
+        this.name = 'GitOperationError';
+    }
+}
+exports.GitOperationError = GitOperationError;
+/**
+ * Erreur de configuration Git manquante ou invalide
+ */
+class GitConfigurationError extends GitOperationError {
+    constructor(message, missingConfig) {
+        super(message, 'configuration', { missingConfig });
+        this.name = 'GitConfigurationError';
+    }
+}
+exports.GitConfigurationError = GitConfigurationError;
+/**
+ * Erreur quand un fichier demandé n'existe pas
+ */
+class FileNotFoundError extends GitOperationError {
+    constructor(filePath, branch) {
+        super(`File "${filePath}" not found in branch "${branch}"`, 'file_read', { filePath, branch });
+        this.filePath = filePath;
+        this.branch = branch;
+        this.name = 'FileNotFoundError';
+    }
+}
+exports.FileNotFoundError = FileNotFoundError;
+/**
+ * Erreur quand une branche demandée n'existe pas
+ */
+class BranchNotFoundError extends GitOperationError {
+    constructor(branch) {
+        super(`Branch "${branch}" not found`, 'branch_access', { branch });
+        this.branch = branch;
+        this.name = 'BranchNotFoundError';
+    }
+}
+exports.BranchNotFoundError = BranchNotFoundError;
+/**
+ * Erreur lors de la création d'un PR (conflit, branche existante, etc.)
+ */
+class PRCreationError extends GitOperationError {
+    constructor(message, attemptedBranch, conflictingFiles) {
+        super(message, 'pr_creation', { attemptedBranch, conflictingFiles });
+        this.attemptedBranch = attemptedBranch;
+        this.conflictingFiles = conflictingFiles;
+        this.name = 'PRCreationError';
+    }
+}
+exports.PRCreationError = PRCreationError;
+/**
+ * Erreur lors des opérations de fermeture de PR
+ */
+class PRClosureError extends GitOperationError {
+    constructor(message, prBranch, reason) {
+        super(message, 'pr_closure', { prBranch, reason });
+        this.prBranch = prBranch;
+        this.reason = reason;
+        this.name = 'PRClosureError';
+    }
+}
+exports.PRClosureError = PRClosureError;
+/**
+ * Erreur de concurrence lors de l'allocation de numéros de PR
+ */
+class ConcurrencyError extends GitOperationError {
+    constructor(message, resourceType, retryCount) {
+        super(message, 'concurrency', { resourceType, retryCount });
+        this.resourceType = resourceType;
+        this.retryCount = retryCount;
+        this.name = 'ConcurrencyError';
+    }
+}
+exports.ConcurrencyError = ConcurrencyError;
+/**
+ * Error thrown when a Git tag creation operation fails.
+ */
+class TagCreationError extends GitOperationError {
+    constructor(tagName, message, details) {
+        super(`Failed to create tag "${tagName}": ${message}`, 'tag_creation', { ...details, tagName });
+        this.tagName = tagName;
+        this.name = 'TagCreationError';
+        this.tagName = tagName;
+    }
+}
+exports.TagCreationError = TagCreationError;