agentic-api 2.0.31 → 2.0.491

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

@@ -321,7 +321,7 @@ async function gitLoadPR(git, branch) {
         if (!metadata) {
             throw new errors_1.GitOperationError(`PR not found for branch ${branch}`, 'pr_load', { branch });
         }
-        const files = metadata.files || await (0, repo_tools_1.gitGetDiffFiles)(git, branch, metadata?.mergeBase, '.md');
+        const files = await (0, repo_tools_1.gitGetDiffFiles)(git, branch, metadata?.mergeBase, '.md');
         // Récupérer les infos du dernier commit de la branche
         const log = await git.log({ from: branch, to: branch, maxCount: 1 });
         const lastCommit = log.latest;
@@ -407,6 +407,21 @@ async function gitClosePRRobust(git, branch, closedBy, message, config) {
         if (!originalMetadata) {
             throw new errors_1.PRClosureError(`Could not find metadata on branch ${branch}. Cannot close.`, branch, 'metadata_not_found');
         }
+        // 2. Nettoyer tout état de merge en cours avant de commencer
+        try {
+            await git.raw(['merge', '--abort']).catch(() => {
+                // Ignorer si pas de merge en cours
+            });
+            // Reset de l'index au cas où il serait dans un état instable
+            await git.raw(['reset', '--merge']).catch(() => {
+                // Ignorer si pas nécessaire
+            });
+        }
+        catch (cleanupError) {
+            if (gitConf.verbose) {
+                console.warn('Cleanup before merge failed (non-critical):', cleanupError);
+            }
+        }
         // 3. Update the metadata note on the PR branch itself to mark it as closed
         const finalMetadata = {
             ...originalMetadata,
@@ -420,32 +435,106 @@ async function gitClosePRRobust(git, branch, closedBy, message, config) {
         await (0, repo_tools_1.gitWriteNote)(git, headCommitHash, finalMetadata, gitConf.gitNotes.namespace);
         // 4. Now, merge the updated PR branch into the target branch
         await git.checkout(originalMetadata.mergeBase || gitConf.draftBranch);
-        const mergeResult = await git
-            .env({
-            GIT_AUTHOR_NAME: closedBy.name,
-            GIT_AUTHOR_EMAIL: closedBy.email,
-            GIT_COMMITTER_NAME: closedBy.name,
-            GIT_COMMITTER_EMAIL: closedBy.email,
-        })
-            .merge([
-            '--no-ff', '-X', 'theirs', '-m', `Merge branch '${branch}'`, branch
-        ]);
+        // 5. Stratégie de merge robuste : FORCER la préservation des changements de la branche PR
+        // Note: "ours" dans ce contexte signifie "garder la version de la branche qu'on merge" (la PR)
+        // car nous sommes sur rule-editor et on merge la PR
+        let mergeResult;
+        try {
+            mergeResult = await git
+                .env({
+                GIT_AUTHOR_NAME: closedBy.name,
+                GIT_AUTHOR_EMAIL: closedBy.email,
+                GIT_COMMITTER_NAME: closedBy.name,
+                GIT_COMMITTER_EMAIL: closedBy.email,
+            })
+                .merge([
+                '--no-ff',
+                '--strategy', 'recursive',
+                '--strategy-option', 'theirs',
+                '-m', `Merge branch '${branch}'`,
+                branch
+            ]);
+        }
+        catch (mergeError) {
+            if (gitConf.verbose) {
+                console.error('Merge failed with recursive/theirs, trying ours strategy:', mergeError);
+            }
+            // Nettoyer le merge échoué
+            await git.raw(['merge', '--abort']).catch(() => { });
+            // Stratégie de fallback ultra-agressive: stratégie "ours" qui prend TOUJOURS la version de la branche source
+            // ATTENTION: Ici "ours" = la branche de destination (rule-editor), donc on inverse la logique
+            // Solution: utiliser --strategy-option theirs avec merge forcé
+            try {
+                // Récupérer les fichiers de la PR
+                const prFiles = originalMetadata.files || [];
+                // Merger avec stratégie ours d'abord (pour créer le commit de merge)
+                await git
+                    .env({
+                    GIT_AUTHOR_NAME: closedBy.name,
+                    GIT_AUTHOR_EMAIL: closedBy.email,
+                    GIT_COMMITTER_NAME: closedBy.name,
+                    GIT_COMMITTER_EMAIL: closedBy.email,
+                })
+                    .merge([
+                    '--no-ff',
+                    '--strategy', 'ours',
+                    '-m', `Merge branch '${branch}'`,
+                    branch
+                ]);
+                // Puis checkout des fichiers depuis la branche PR pour forcer leurs contenus
+                for (const file of prFiles) {
+                    try {
+                        await git.raw(['checkout', branch, '--', file]);
+                    }
+                    catch (fileError) {
+                        if (gitConf.verbose) {
+                            console.warn(`Could not checkout ${file} from ${branch}:`, fileError);
+                        }
+                    }
+                }
+                // Amend le commit de merge avec les bons contenus
+                await git.commit('--amend', ['--no-edit'], {
+                    '--author': `${closedBy.name} <${closedBy.email}>`
+                });
+                mergeResult = { summary: { changes: prFiles.length } };
+            }
+            catch (fallbackError) {
+                throw new errors_1.PRClosureError(`Failed to merge PR ${branch} with all strategies: ${mergeError}\nFallback error: ${fallbackError}`, branch, 'merge_failed');
+            }
+        }
         const result = {
             metadata: finalMetadata,
             failed: false,
-            conflicts: mergeResult.conflicts,
+            conflicts: mergeResult?.conflicts || [],
             raw: mergeResult,
         };
         return result;
     }
     catch (error) {
+        // Nettoyer l'état en cas d'erreur
+        try {
+            await git.raw(['merge', '--abort']).catch(() => { });
+            await git.raw(['reset', '--merge']).catch(() => { });
+        }
+        catch (cleanupError) {
+            if (gitConf.verbose) {
+                console.error('Failed to cleanup merge state:', cleanupError);
+            }
+        }
         if (error instanceof errors_1.PRClosureError)
             throw error;
         throw new errors_1.PRClosureError(`Failed to close PR ${branch}: ${error}`, branch, 'unknown');
     }
     finally {
         if (currentBranch) {
-            await git.checkout(currentBranch);
+            try {
+                await git.checkout(currentBranch);
+            }
+            catch (checkoutError) {
+                if (gitConf.verbose) {
+                    console.error(`Failed to checkout back to ${currentBranch}:`, checkoutError);
+                }
+            }
         }
         (0, repo_tools_1.unlock)('checkout');
     }
@@ -506,6 +595,21 @@ async function gitNewValidationRequest(git, files, description, author, options
             throw new errors_1.PRCreationError('Author is required', undefined, files);
         }
         try {
+            // ✅ CLEANUP: Nettoyer tout état de merge corrompu avant de créer la branche
+            // Cela évite l'erreur "you need to resolve your current index first"
+            try {
+                await git.raw(['merge', '--abort']).catch(() => {
+                    // Ignorer si pas de merge en cours
+                });
+                await git.raw(['reset', '--merge']).catch(() => {
+                    // Ignorer si pas nécessaire
+                });
+            }
+            catch (cleanupError) {
+                if (gitConfig.verbose) {
+                    console.warn('Cleanup before branch creation failed (non-critical):', cleanupError);
+                }
+            }
             const nextID = await gitGetNextPRNumber(git, validationBranchPrefix);
             const newBranchName = `${validationBranchPrefix}${nextID}`;
             await git.checkoutBranch(newBranchName, sourceBranch);

package/dist/src/rules/git/repo.tools.d.ts

@@ -2,11 +2,32 @@ import { SimpleGit } from 'simple-git';
 import { RulesGitConfig, PRMetadata, GitCommitHistory, GitFileSummary } from '../types';
 export declare function lock(key: string): Promise<void>;
 export declare function unlock(key: string): void;
+/**
+ * Valide si une valeur est un entier valide pour un ID
+ *
+ * Un ID valide doit être:
+ * - Un nombre (type number)
+ * - Un entier (pas de décimales)
+ * - Supérieur à 999 (réservé pour les IDs système)
+ * - Fini (pas NaN, pas Infinity)
+ *
+ * @param id Valeur à valider
+ * @returns true si l'ID est valide, false sinon
+ *
+ * @example
+ * isValidInt(1234) // true
+ * isValidInt(999) // false (trop petit)
+ * isValidInt(1.5) // false (pas un entier)
+ * isValidInt(NaN) // false
+ * isValidInt("1234") // false (pas un nombre)
+ */
+export declare function isValidInt(id: any): boolean;
 /**
  * Configuration et initialisation du client Git
+ * @param defaultConfig Configuration partielle optionnelle pour override
  * @returns Configuration Git avec l'instance et les chemins
  */
-export declare function gitLoad(defaultConfig?: RulesGitConfig): RulesGitConfig;
+export declare function gitLoad(defaultConfig?: Partial<RulesGitConfig>): RulesGitConfig;
 /**
  * Récupère la prévisualisation d'un fichier depuis Git (opération bas niveau atomique),
  * sans les métadonnées.

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

@@ -35,6 +35,7 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.lock = lock;
 exports.unlock = unlock;
+exports.isValidInt = isValidInt;
 exports.gitLoad = gitLoad;
 exports.gitGetFilePreview = gitGetFilePreview;
 exports.gitGetFileContent = gitGetFileContent;
@@ -76,11 +77,50 @@ function unlock(key) {
         releasers.delete(key);
     }
 }
+/**
+ * Valide si une valeur est un entier valide pour un ID
+ *
+ * Un ID valide doit être:
+ * - Un nombre (type number)
+ * - Un entier (pas de décimales)
+ * - Supérieur à 999 (réservé pour les IDs système)
+ * - Fini (pas NaN, pas Infinity)
+ *
+ * @param id Valeur à valider
+ * @returns true si l'ID est valide, false sinon
+ *
+ * @example
+ * isValidInt(1234) // true
+ * isValidInt(999) // false (trop petit)
+ * isValidInt(1.5) // false (pas un entier)
+ * isValidInt(NaN) // false
+ * isValidInt("1234") // false (pas un nombre)
+ */
+function isValidInt(id) {
+    // Vérifier que c'est un nombre
+    if (typeof id !== 'number') {
+        return false;
+    }
+    // Vérifier que c'est un nombre fini (pas NaN, pas Infinity)
+    if (!Number.isFinite(id)) {
+        return false;
+    }
+    // Vérifier que c'est un entier
+    if (!Number.isInteger(id)) {
+        return false;
+    }
+    // Vérifier que c'est supérieur à 999
+    if (id <= 999) {
+        return false;
+    }
+    return true;
+}
 // Global variables for git config and instance
 let gitConfig;
 let git;
 /**
  * Configuration et initialisation du client Git
+ * @param defaultConfig Configuration partielle optionnelle pour override
  * @returns Configuration Git avec l'instance et les chemins
  */
 function gitLoad(defaultConfig) {
@@ -99,6 +139,13 @@ function gitLoad(defaultConfig) {
     const validationToken = defaultConfig?.validationToken || process.env.DEFAULT_VALIDATION_TOKEN;
     const sshKeyPath = process.env.GIT_SSH_KEY_PATH;
     const sshPassphrase = process.env.GIT_SSH_PASSPHRASE;
+    // Configuration de la validation des IDs
+    const withID = defaultConfig?.withID !== undefined
+        ? defaultConfig.withID
+        : process.env.GIT_WITH_ID == 'true';
+    const strictID = defaultConfig?.strictID !== undefined
+        ? defaultConfig.strictID
+        : process.env.GIT_STRICT_ID == 'true';
     if (!repoPath || !draftBranch || !uploadPath || !mainBranch || !validationToken) {
         throw new errors_1.GitConfigurationError(messages_1.i18nRules.git_config_incomplete, 'repoPath|draftBranch|uploadPath|mainBranch|validationToken');
     }
@@ -152,7 +199,9 @@ function gitLoad(defaultConfig) {
         remoteUrl,
         verbose,
         canForce: defaultConfig?.canForce,
-        reset: defaultConfig?.reset
+        reset: defaultConfig?.reset,
+        withID,
+        strictID
     };
     git = gitInstance;
     return gitConfig;

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

@@ -122,13 +122,10 @@ export interface FrontMatter {
     id?: number;
     /** Titre descriptif de la règle */
     title: string;
+    /** Ancien nom de fichier (pour renommage) */
     oldfile?: string;
-    /** Liste des identifiants/alias pour cette règle (pour recherche) */
-    slugs: string[];
-    /** Version de la règle (optionnelle, format libre) */
-    version?: string;
-    /** Auteur original de la règle */
-    author?: RuleUser;
+    /** Auteur original de la règle (format git: "Name <email>") */
+    author?: string;
     /** Email du validateur assigné à cette règle */
     validator?: string;
     /** Indique si la règle est finalisée et prête pour validation */
@@ -136,14 +133,8 @@ export interface FrontMatter {
     /** Service ou département propriétaire de cette règle */
     service?: string;
     /** Type de contenu de ce document */
-    role?: "rule" | "template" | "rule-helper" | "web" | "document";
-    /** Tags de catégorisation pour recherche et filtrage */
-    tags?: string[];
-    /** Date de dernière modification explicite */
-    lastModified?: Date;
-    /** Clé personnalisée pour données additionnelles */
-    custom?: string;
-    [key: string]: string | Date | number | string[] | RuleUser | boolean | undefined;
+    role?: "rule" | "template" | "rule-helper" | "web" | "document" | string;
+    [key: string]: string | Date | number | boolean | undefined;
 }
 /**
  * Représente un élément de l'historique Git d'une règle
@@ -282,6 +273,17 @@ export interface RulesGitConfig {
     remoteUrl?: string;
     /** Active les logs verbeux pour debug */
     verbose?: boolean;
+    /**
+     * Active la validation et génération automatique des IDs dans le matter
+     * @default false (pour compatibilité ascendante)
+     */
+    withID?: boolean;
+    /**
+     * Mode strict : rejeter les documents sans ID valide
+     * Nécessite withID: true
+     * @default false (génère l'ID si manquant)
+     */
+    strictID?: boolean;
 }
 /**
  * Configuration des options de concurrence pour les opérations Git
@@ -508,3 +510,14 @@ export interface GitHealthStatus {
     /** Recommandations de réparation */
     recommendations: string[];
 }
+/**
+ * Rapport de migration des notes Git
+ */
+export interface GitPrNoteMigrationReport {
+    migrated: number;
+    alreadyOk: number;
+    lost: Array<{
+        branch: string;
+        prNumber: number;
+    }>;
+}

package/dist/src/rules/utils.matter.d.ts

@@ -30,10 +30,6 @@ import { FrontMatter, Rule } from "./types";
  * ```
  */
 export declare function matterParse(markdown: string): {
-    matter: {};
-    content: string;
-    data?: undefined;
-} | {
     data: any;
     content: string;
     matter: any;

package/dist/src/rules/utils.matter.js

@@ -38,7 +38,7 @@ function matterParse(markdown) {
     // 1. Séparer les lignes
     const lines = markdown.split(/\r?\n/);
     if (lines[0].trim() !== '---') {
-        return { matter: {}, content: markdown }; // Pas de front-matter
+        return { matter: {}, content: markdown, data: {} }; // Pas de front-matter
     }
     // 2. Trouver la ligne de fermeture '---'
     let end = 1;
@@ -53,6 +53,17 @@ function matterParse(markdown) {
         const [rawKey, ...rawValue] = line.split(':');
         const key = rawKey.trim();
         const value = rawValue.join(':').trim();
+        // Détection de null explicite (YAML: null, ~) - ne pas créer la clé
+        if (value === 'null' || value === '~' || value === 'Null' || value === 'NULL') {
+            // Si la valeur est null, ne pas créer la clé (comme undefined)
+            continue;
+        }
+        // Si la valeur est vide (chaîne vide après trim), définir comme chaîne vide
+        // L'utilisateur peut définir un string vide pour indiquer qu'il n'a pas de valeur pour ce champ
+        if (!value) {
+            matter[key] = '';
+            continue;
+        }
         // Détection et parsing des arrays YAML
         if (value.startsWith('[') && value.endsWith(']')) {
             try {
@@ -86,10 +97,14 @@ function matterParse(markdown) {
     }
     // 4. parse slugs and tags as arrays
     // Ensure slugs is always an array
-    // TODO: this code is not clean enough
+    // FIXME: this code is dead no more slugs in matter
     if (matter.slugs && typeof matter.slugs === 'string') {
         matter.slugs = matter.slugs.split(',').map((s) => s.trim()).filter((s) => s.length);
     }
+    // Ensure id is always a number
+    if (matter.id && typeof matter.id === 'string') {
+        matter.id = Number(matter.id);
+    }
     // Ensure tags is always an array
     if (matter.tags && typeof matter.tags === 'string') {
         const tagsStr = matter.tags;
@@ -115,21 +130,34 @@ function matterSerializeFromRule(rule) {
 function matterSerialize(content, matter) {
     // Créer un objet propre pour le front-matter (exclure oldfile)
     const cleanMatter = { ...matter };
-    //
-    // FIX: Convertir la Date en string pour éviter l'erreur YAML
-    cleanMatter.lastModified = (cleanMatter.lastModified instanceof Date) ? `${new Date().toISOString()}` : `${cleanMatter.lastModified}`;
     const result = Object.keys(cleanMatter).reduce((acc, key) => {
         const value = cleanMatter[key];
+        // Ignorer les valeurs undefined, null ou chaînes vides
+        if (value === undefined || value === null || value === '') {
+            return acc;
+        }
         if (Array.isArray(value)) {
             return acc + `${key}: '${value.join(',')}'\n`;
         }
+        else if (typeof value === 'number') {
+            // ✅ FIX: Ne PAS mettre de guillemets autour des nombres
+            return acc + `${key}: ${value}\n`;
+        }
+        else if (typeof value === 'boolean') {
+            // ✅ FIX: Ne PAS mettre de guillemets autour des booléens
+            return acc + `${key}: ${value}\n`;
+        }
+        else if (value instanceof Date) {
+            // ✅ FIX: Convertir Date en ISO string avec guillemets
+            return acc + `${key}: '${value.toISOString()}'\n`;
+        }
         else {
+            // Pour les strings, mettre des guillemets
             return acc + `${key}: '${value}'\n`;
         }
     }, '');
     return `---
-${result}
----
+${result}---
 ${content}`;
 }
 /**

package/dist/src/scrapper.d.ts

@@ -1,3 +1,4 @@
+import { FrontMatter } from "./rules/types";
 export declare function extractCaptcha(base64Image: string, openai: any): Promise<{
     number: any;
     cost: number;
@@ -7,49 +8,41 @@ export declare function extractCaptcha(base64Image: string, openai: any): Promis
  *
  * @param {string} inputfile - The name of the PDF file being processed
  * @param {any} pdfData - The extracted content from the PDF file
- * @param {any} openai - The OpenAI client instance
  * @param {any[]} links - Optional array of links extracted from the PDF to be integrated into the markdown
+ * @param {string} model - The model to use for parsing (default: "MEDIUM-fast")
  * @returns {Promise<{markdown: string, cost: number}>} - The parsed markdown content and the cost of the API call
  */
-export declare function callGPTForParsingPDF(inputfile: string, pdfData: any, openai: any, links?: any[]): Promise<{
-    markdown: any;
+export declare function callLLMForParsingPDF(inputfile: string, pdfData: any, links?: any[], model?: string): Promise<{
+    markdown: string;
     cost: number;
 }>;
-/**
- * Convertit un document HTML en markdown en appelant le modèle GPT (ex: gpt-4.1)
- * pour analyser et reformater le document.
- *
- * @param {any} htmlData - Le document HTML à transformer en markdown.
- * @param {any} openai - L'instance OpenAI configurée pour appeler l'API.
- * @param {boolean} simple - Si true, utilise un prompt simplifié.
- * @returns {Promise<Object>} - Le contenu markdown structuré créé par le modèle LLM.
- */
-export declare function callGPTForParsingHTML(html: string, openai: any): Promise<any>;
 /**
  * Parses an HTML file and converts it to markdown using GPT.
  *
  * @param {string} output - The directory path where the output markdown file will be saved.
  * @param {string} file - The path to the HTML file to be parsed.
  * @param {string} service - The service name used as part of the output filename output.
- * @param {any} openai - The OpenAI instance to use for the GPT API calls.
+ * @param {string} model - The model to use for parsing (default: "MEDIUM-fast")
  * @returns {Promise<{markdown: string, cost: number}>} - The generated markdown content and the cost of the GPT API call.
  */
-export declare function html2markdown(output: string, file: string, service: string, openai: any): Promise<{
-    markdown: any;
+export declare function html2markdown(output: string, file: string, service: string, model?: string): Promise<{
+    markdown: string;
     cost: number;
 }>;
 /**
  * Parse un PDF en effectuant :
  * 1. Le nettoyage du PDF avec Ghostscript.
  * 2. Sa conversion en XML via pdftohtml.
- * 3. (Optionnellement) Le passage du contenu converti au modèle GPT pour analyser la structure.
+ * 3. (Optionnellement) Le passage du contenu converti au modèle LLM pour analyser la structure.
  *
- * @param {string} file - Chemin vers le fichier PDF à analyser.
- * @param {any} openai - L'instance configurée pour appeler l'API OpenAI.
- * @returns {Promise<any>} - Le markdown structuré (issue de GPT) ou tout autre traitement souhaité.
+ * @param {string} outputDir - Dossier de sortie pour le fichier markdown.
+ * @param {string} pdf - Chemin vers le fichier PDF à analyser.
+ * @param {FrontMatter|null} matter - Métadonnées du document (title, service, author, role). Si null, utilise le nom du PDF pour le titre.
+ * @param {string} model - Le modèle à utiliser (défaut: "MEDIUM-fast").
+ * @returns {Promise<{markdown: string, cost: number, outputPath: string}>} - Le markdown structuré, le coût et le chemin du fichier de sortie.
  */
-export declare function pdf2markdown(folder: string, file: string, service: string, openai: any): Promise<{
-    markdown: any;
+export declare function pdf2markdown(outputDir: string, pdf: string, matter: FrontMatter | null, model?: string): Promise<{
+    markdown: string;
     cost: number;
     outputPath: string;
 }>;