agentic-api 2.0.491 → 2.0.585

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

@@ -56,7 +56,11 @@ export declare function gitReadFileOutsideRepo(git: SimpleGit, filePath: string)
     content: string;
     date: Date;
 }>;
-export declare function gitGetFileHistory(git: SimpleGit, filename: string, hash?: string): Promise<GitCommitHistory[]>;
+export declare function gitGetFileHistory(git: SimpleGit, filename: string, options?: {
+    hash?: string;
+    branch?: string;
+    maxCommits?: number;
+}): Promise<GitCommitHistory[]>;
 /**
  * Récupère le dernier commit d'une branche (opération bas niveau atomique)
  * @param git Instance SimpleGit

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

@@ -338,10 +338,23 @@ async function gitReadFileOutsideRepo(git, filePath) {
         throw error;
     }
 }
-async function gitGetFileHistory(git, filename, hash) {
+async function gitGetFileHistory(git, filename, options) {
+    // - Normalisation des paramètres pour compatibilité
     try {
-        const log = await git.log({ file: filename });
-        const all = log.all.map(commit => ({
+        // - Utiliser git.log() pour obtenir l'historique des commits
+        // - git.log() retourne déjà les commits du plus récent au plus ancien (ordre standard Git)
+        const branch = options?.branch || 'HEAD';
+        const logArgs = [];
+        if (branch !== 'HEAD') {
+            logArgs.push(branch);
+        }
+        logArgs.push('--', filename);
+        const log = await git.log(logArgs);
+        if (log.all.length === 0) {
+            return [];
+        }
+        // - Construire l'historique (déjà dans l'ordre du plus récent au plus ancien)
+        let all = log.all.map(commit => ({
             hash: commit.hash,
             date: new Date(commit.date),
             message: commit.message,
@@ -350,10 +363,44 @@ async function gitGetFileHistory(git, filename, hash) {
                 email: commit.author_email
             }
         }));
-        // Si un hash est fourni, retourner le contenu du fichier à ce hash
-        if (hash) {
-            const fileContent = await gitGetFileContent(git, filename, hash);
-            const index = all.findIndex(commit => commit.hash === hash);
+        // - Si un hash est fourni, s'assurer qu'il est inclus avant l'échantillonnage
+        let requestedHashIndex = -1;
+        if (options?.hash) {
+            requestedHashIndex = all.findIndex(commit => commit.hash === options.hash);
+        }
+        // - Limitation du nombre de commits avec échantillonnage uniforme
+        // - Garantit que le premier (plus récent) et dernier (plus ancien) commit sont inclus
+        // - Si un hash spécifique est demandé, il est aussi garanti d'être inclus
+        if (options?.maxCommits && all.length > options.maxCommits) {
+            const step = Math.ceil((all.length - 2) / (options.maxCommits - 2)) || 1;
+            const sampled = [all[0]]; // Premier commit (plus récent)
+            const includedIndices = new Set([0]); // Track des indices déjà inclus
+            // - Si un hash spécifique est demandé et n'est pas le premier, l'ajouter
+            if (requestedHashIndex > 0 && requestedHashIndex < all.length - 1) {
+                sampled.push(all[requestedHashIndex]);
+                includedIndices.add(requestedHashIndex);
+            }
+            // - Échantillonnage des commits intermédiaires
+            for (let i = 1; i < all.length - 1; i += step) {
+                if (!includedIndices.has(i)) {
+                    sampled.push(all[i]);
+                    includedIndices.add(i);
+                }
+                if (sampled.length >= options.maxCommits - 1)
+                    break;
+            }
+            // - Dernier commit (plus ancien) si on a encore de la place
+            if (sampled.length < options.maxCommits && all.length > 1 && !includedIndices.has(all.length - 1)) {
+                sampled.push(all[all.length - 1]);
+            }
+            // - Trier par date décroissante pour maintenir l'ordre (plus récent en premier)
+            sampled.sort((a, b) => b.date.getTime() - a.date.getTime());
+            all = sampled;
+        }
+        // - Si un hash est fourni, retourner le contenu du fichier à ce hash
+        if (options?.hash) {
+            const fileContent = await gitGetFileContent(git, filename, options.hash);
+            const index = all.findIndex(commit => commit.hash === options.hash);
             if (index !== -1 && fileContent) {
                 all[index] = fileContent;
             }

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

@@ -334,6 +334,20 @@ export interface GitCommitHistory {
     /** Branche où s'est produit ce commit (optionnel) */
     branch?: string;
 }
+/**
+ * Structure simplifiée d'un commit pour la prévisualisation
+ *
+ * Utilisée dans loadPreview() pour retourner uniquement les informations essentielles
+ * sans le contenu complet du commit.
+ */
+export interface CommitPreview {
+    /** Hash unique du commit */
+    hash: string;
+    /** Date et heure du commit */
+    date: Date;
+    /** Nom de l'auteur du commit */
+    author: string;
+}
 /**
  * Résumé d'un fichier Git avec son commit associé
  *

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

@@ -40,23 +40,3 @@ export declare function matterParse(markdown: string): {
 */
 export declare function matterSerializeFromRule(rule: Rule): string;
 export declare function matterSerialize(content: string, matter: FrontMatter | any): string;
-/**
- * Extrait le front-matter (entre les deux premiers '---') et le contenu Markdown.
- * Fonction 100% vanilla : aucun paquet externe requis.
- * PROS:
- * Code plus propre et maintenable
- *  - Typage TypeScript strict
- *  - Plus robuste (ignore lignes indentées)
- *  - Séparation des responsabilités
- *  - Meilleure architecture (parsing pur)
- * CONS:
- *  - Perte de fonctionnalité (slugs/tags)
- *
- * @param markdown Texte Markdown brut
- * @returns Objet avec matter, content et data
- */
-export declare function matterParse_OTHER(markdown: string): {
-    matter: Record<string, any>;
-    content: string;
-    data: Record<string, any>;
-};

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

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.matterParse = matterParse;
 exports.matterSerializeFromRule = matterSerializeFromRule;
 exports.matterSerialize = matterSerialize;
-exports.matterParse_OTHER = matterParse_OTHER;
 /**
  * Parse le front-matter YAML et le contenu Markdown d'un document
  *
@@ -152,85 +151,54 @@ function matterSerialize(content, matter) {
             return acc + `${key}: '${value.toISOString()}'\n`;
         }
         else {
-            // Pour les strings, mettre des guillemets
-            return acc + `${key}: '${value}'\n`;
+            const formatted = formatYAMLString(value.toString());
+            return acc + `${key}: ${formatted}\n`;
         }
     }, '');
     return `---
 ${result}---
 ${content}`;
 }
-/**
- * Extrait le front-matter (entre les deux premiers '---') et le contenu Markdown.
- * Fonction 100% vanilla : aucun paquet externe requis.
- * PROS:
- * Code plus propre et maintenable
- *  - Typage TypeScript strict
- *  - Plus robuste (ignore lignes indentées)
- *  - Séparation des responsabilités
- *  - Meilleure architecture (parsing pur)
- * CONS:
- *  - Perte de fonctionnalité (slugs/tags)
- *
- * @param markdown Texte Markdown brut
- * @returns Objet avec matter, content et data
- */
-function matterParse_OTHER(markdown) {
-    // 1. Séparer les lignes
-    const lines = markdown.split(/\r?\n/);
-    if (lines[0].trim() !== '---') {
-        return { matter: {}, content: markdown, data: {} }; // Pas de front-matter
+function formatYAMLString(value) {
+    const shouldQuote = needsQuotes(value);
+    if (!shouldQuote) {
+        return value;
     }
-    // 2. Trouver la ligne de fermeture '---'
-    let end = 1;
-    while (end < lines.length && lines[end].trim() !== '---')
-        end++;
-    // 3. Parser le bloc front-matter (simple clé-valeur)
-    const matter = {};
-    for (let i = 1; i < end; i++) {
-        const line = lines[i];
-        if (!line.trim())
-            continue; // ignorer les lignes vides
-        // Ignorer les lignes indentées (structures complexes non supportées)
-        if (line.startsWith(' ') || line.startsWith('\t')) {
-            continue;
-        }
-        const trimmedLine = line.trim();
-        if (trimmedLine.includes(':')) {
-            const [rawKey, ...rawValue] = trimmedLine.split(':');
-            const key = rawKey.trim();
-            const value = rawValue.join(':').trim();
-            if (value) {
-                // Détection et parsing des arrays YAML
-                if (value.startsWith('[') && value.endsWith(']')) {
-                    try {
-                        const parsed = JSON.parse(value);
-                        if (Array.isArray(parsed)) {
-                            matter[key] = parsed;
-                        }
-                        else {
-                            matter[key] = value.replace(/^["']|["']$/g, '');
-                        }
-                    }
-                    catch (e) {
-                        matter[key] = value.replace(/^["']|["']$/g, '');
-                    }
-                }
-                // Tentative de typage léger : nombre, booléen, sinon chaîne
-                else if (/^(true|false)$/i.test(value)) {
-                    matter[key] = value.toLowerCase() === 'true';
-                }
-                else if (!isNaN(Number(value)) && value !== '') {
-                    matter[key] = Number(value);
-                }
-                else {
-                    matter[key] = value.replace(/^["']|["']$/g, '');
-                }
-            }
-        }
+    if (process.env.DEBUG_YAML === '1') {
+        console.warn('[matterSerialize] quoting value:', value);
     }
-    // 4. Restituer le contenu Markdown sans le front-matter
-    const content = lines.slice(end + 1).join('\n').trimStart();
-    const data = matter;
-    return { data, content, matter };
+    const escaped = value.replace(/'/g, "''");
+    return `'${escaped}'`;
+}
+function needsQuotes(value) {
+    if (value.length === 0) {
+        return true;
+    }
+    const firstChar = value[0];
+    const lastChar = value[value.length - 1];
+    if (firstChar === ' ' || lastChar === ' ') {
+        return true;
+    }
+    if (/[:#{}\[\],&*?]/.test(value)) {
+        return true;
+    }
+    if (/^-/.test(value)) {
+        return true;
+    }
+    if (/^\d/.test(value)) {
+        return true;
+    }
+    if (value.includes('\n')) {
+        return true;
+    }
+    if (value.includes('- ')) {
+        return true;
+    }
+    if (value.includes('"')) {
+        return true;
+    }
+    if (value.includes("'")) {
+        return true;
+    }
+    return false;
 }

package/dist/src/scrapper.js

@@ -13,7 +13,7 @@ const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
 const jsdom_1 = require("jsdom");
 const readability_1 = require("@mozilla/readability");
-const pricing_llm_1 = require("./pricing.llm");
+const pricing_1 = require("./llm/pricing");
 const prompts_1 = require("./prompts");
 const utils_1 = require("./utils");
 const execute_1 = require("./execute");
@@ -37,7 +37,7 @@ async function extractCaptcha(base64Image, openai) {
         messages: [{ role: "user", content }],
         max_completion_tokens: 50,
     });
-    const cost = (0, pricing_llm_1.calculateCost)(model, response.usage);
+    const cost = (0, pricing_1.calculateCost)(model, response.usage);
     // Récupérer la réponse markdown
     const number = response.choices[0].message.content;
     return { number, cost };

package/dist/src/utils.d.ts

@@ -1,13 +1,5 @@
 import { ParsedFunctionToolCall } from "openai/resources/beta/chat/completions";
 import { AgentConfig, AgenticContext } from "./types";
-import OpenAI from "openai";
-/**
- * global openai instance
- */
-declare global {
-    var _openaiInstance_: OpenAI | undefined;
-}
-export declare const openaiInstance: (envKey?: string, baseUrl?: string) => OpenAI;
 /**
  * Converts a string to a URL-friendly slug
  * @param text The text to convert to a slug

package/dist/src/utils.js

@@ -1,36 +1,9 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.toSlug = exports.openaiInstance = void 0;
+exports.toSlug = void 0;
 exports.injectTransferTools = injectTransferTools;
 exports.handleTransferCall = handleTransferCall;
 const prompts_1 = require("./prompts");
-const openai_1 = __importDefault(require("openai"));
-const openaiInstance = function (envKey, baseUrl) {
-    if (globalThis._openaiInstance_) {
-        return globalThis._openaiInstance_;
-    }
-    if (!envKey) {
-        throw new Error('AI API key is missing');
-    }
-    // 
-    // use multiple fallback if envKey is not set
-    const options = {
-        apiKey: process.env[envKey] || envKey || process.env.API_LLM_KEY || process.env.OPENAI_API_KEY,
-        timeout: 60000 * 15
-    };
-    if (baseUrl) {
-        options.baseURL = baseUrl;
-    }
-    globalThis._openaiInstance_ = new openai_1.default(options);
-    if (!globalThis._openaiInstance_) {
-        throw new Error('OpenAI instance has not been initialized');
-    }
-    return globalThis._openaiInstance_;
-};
-exports.openaiInstance = openaiInstance;
 /**
  * Converts a string to a URL-friendly slug
  * @param text The text to convert to a slug

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentic-api",
-  "version": "2.0.491",
+  "version": "2.0.585",
   "description": "API pour l'orchestration d'agents intelligents avec séquences et escalades automatiques",
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",