agentic-api 2.0.314 → 2.0.491

package/dist/src/execute/shared.js

@@ -0,0 +1,188 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DummyWritable = void 0;
+exports.sendFeedback = sendFeedback;
+exports.normalizeOptionsForResponses = normalizeOptionsForResponses;
+exports.normalizedFunctionCallFromResponse = normalizedFunctionCallFromResponse;
+exports.normalizeOutputFromResponses = normalizeOutputFromResponses;
+exports.convertMessagesToResponsesInput = convertMessagesToResponsesInput;
+//
+// Writable vide pour les tests
+exports.DummyWritable = {
+    write: () => { }
+};
+//
+// Envoi de feedback temps réel vers l'UX
+// Informe l'utilisateur de l'état de l'analyse : agent actif, description, usage, state
+function sendFeedback(params) {
+    const { agent, stdout, description, usage, state, verbose } = params;
+    const feedback = {
+        agent,
+        description,
+        usage,
+        state
+    };
+    // if(verbose) {
+    //   console.log('--- DBG sendFeedback:',agent, description || '--', state);
+    // }
+    //
+    // send agent state and description
+    stdout.write(`\n<step>${JSON.stringify(feedback)}</step>\n`);
+}
+/**
+ * Normalise les options pour l'API Responses
+ *
+ * Transforme les paramètres du format Chat Completions vers Responses API:
+ * - Tools: { type: "function", function: {...} } → { type: "function", name, description, parameters, strict }
+ * - Autres transformations futures si nécessaire
+ *
+ * @param options - Options à normaliser
+ * @returns Options normalisées pour Responses API
+ */
+function normalizeOptionsForResponses(options) {
+    const normalized = { ...options };
+    // Transformer les tools au format Responses API
+    if (normalized.tools && normalized.tools.length > 0) {
+        normalized.tools = normalized.tools.map((tool) => {
+            if (tool.type === 'function' && tool.function) {
+                // Format Chat Completions → Responses API
+                return {
+                    type: 'function',
+                    name: tool.function.name,
+                    description: tool.function.description,
+                    parameters: tool.function.parameters,
+                    strict: tool.function.strict ?? true
+                };
+            }
+            // Déjà au bon format ou type différent
+            return tool;
+        });
+    }
+    return normalized;
+}
+/**
+ * Normalise un function call du format Responses vers Chat Completions
+ *
+ * Responses API: { type: "function_call", name, arguments, call_id }
+ * Chat Completions: { id, type: "function", function: { name, arguments } }
+ *
+ * Si déjà au format Chat Completions (avec .function), retourne tel quel
+ *
+ * @param functionCall - Function call au format Responses ou Chat Completions
+ * @returns Function call au format Chat Completions
+ */
+function normalizedFunctionCallFromResponse(functionCall) {
+    // Si déjà au format Chat Completions, retourner tel quel
+    if (functionCall.function) {
+        return functionCall;
+    }
+    // Transformer du format Responses vers Chat Completions
+    return {
+        id: functionCall.call_id,
+        type: "function",
+        function: {
+            name: functionCall.name,
+            arguments: functionCall.arguments
+        }
+    };
+}
+/**
+ * Normalise l'output de l'API Responses vers le format Chat Completions
+ *
+ * Transforme la structure Responses API vers le format attendu par le reste du code
+ *
+ * Format Responses API (result.output array):
+ * - { type: "reasoning", summary: [] }
+ * - { type: "message", content: [{ type: "output_text", text: "..." }] }
+ * - { type: "function_call", name, arguments, call_id }
+ *
+ * Format Chat Completions compatible:
+ * - { choices: [{ message: { content, tool_calls, reasoning_text } }], usage: {...}, id: "..." }
+ *
+ * @param result - Résultat de stream.finalResponse()
+ * @returns Résultat au format Chat Completions avec reasoning_text si présent
+ */
+function normalizeOutputFromResponses(result) {
+    let text = '';
+    let reasoningText = ''; // ✅ Capturer reasoning_text pour modèles reasoning (o-series, gpt-5)
+    const functionCalls = [];
+    // Parcourir les output items pour extraire text, reasoning et function_calls
+    if (result.output && Array.isArray(result.output)) {
+        for (const item of result.output) {
+            // Function calls sont directement dans output
+            if (item.type === 'function_call') {
+                functionCalls.push(item);
+            }
+            // ✅ Capturer reasoning (v5.22.0)
+            else if (item.type === 'reasoning' && item.summary) {
+                reasoningText = Array.isArray(item.summary) ? item.summary.join('\n') : String(item.summary);
+            }
+            // Messages contiennent le texte
+            else if (item.type === 'message' && item.content) {
+                for (const content of item.content) {
+                    if (content.type === 'output_text' && content.text) {
+                        text += content.text;
+                    }
+                }
+            }
+        }
+    }
+    // Transformer tous les function_calls vers le format Chat Completions
+    const toolCalls = functionCalls.map(normalizedFunctionCallFromResponse);
+    // Retourner au format Chat Completions avec reasoning_text optionnel
+    return {
+        choices: [{
+                message: {
+                    tool_calls: toolCalls,
+                    content: text,
+                    reasoning_text: reasoningText || undefined // ✅ Optionnel, seulement si présent
+                }
+            }],
+        usage: {
+            prompt_tokens: result.usage?.input_tokens || 0,
+            completion_tokens: result.usage?.output_tokens || 0,
+            total_tokens: (result.usage?.input_tokens || 0) + (result.usage?.output_tokens || 0)
+        },
+        id: result.id
+    };
+}
+/**
+ * Convertit les messages du stateGraph vers le format Responses API input
+ * Gère les messages normaux, tool_calls (Chat Completions), et function_call_output (Responses)
+ *
+ * Utilisée par:
+ * - readCompletionsStream (responses.ts) pour le follow-up après tool calls
+ * - executeAgentSet (responses.ts) pour préparer l'input initial
+ *
+ * @param messages Messages du stateGraph
+ * @returns Array d'items au format Responses API input
+ */
+function convertMessagesToResponsesInput(messages) {
+    return messages.flatMap((m) => {
+        // ✅ Messages function_call_output ont un format différent (pas de role)
+        if (m.type === 'function_call_output') {
+            return [{ type: m.type, call_id: m.call_id, output: m.output }];
+        }
+        // ✅ Messages avec tool_calls → convertir vers le format Responses API
+        // Documentation: "input_list += response.output" ajoute reasoning + function_calls
+        if (m.tool_calls && m.tool_calls.length > 0) {
+            const result = [];
+            // Ajouter le message assistant si content présent
+            if (m.content) {
+                result.push({ role: m.role, content: m.content });
+            }
+            // Convertir chaque tool_call (Chat Completions) en function_call (Responses)
+            for (const tc of m.tool_calls) {
+                result.push({
+                    type: "function_call",
+                    call_id: tc.id,
+                    name: tc.function.name,
+                    arguments: tc.function.arguments
+                });
+            }
+            return result;
+        }
+        // Messages normaux avec role
+        return [{ role: m.role, content: m.content }];
+    });
+}

package/dist/src/index.js

@@ -24,7 +24,7 @@ __exportStar(require("./utils"), exports);
 __exportStar(require("./types"), exports);
 // StateGraph - nouvelle architecture de gestion des discussions
 __exportStar(require("./stategraph"), exports);
-// Execute
+// Execute (avec feature toggle legacy/responses)
 __exportStar(require("./execute"), exports);
 __exportStar(require("./pricing.llm"), exports);
 // Scrapper

package/dist/src/pricing.llm.d.ts

@@ -8,7 +8,7 @@ type ModelPricing = {
 export declare const modelPricing: Record<string, ModelPricing>;
 export declare function calculateCost(model: string, usage?: CompletionUsage): number;
 export declare function accumulateCost(currentUsage: Usage, model: string, usage?: CompletionUsage): number;
-export declare function LLM(openai: any): any;
+export declare function LLM(openai: any, forceThinking?: boolean): any;
 export declare const LLMxai: any;
 /**
  * Get model mapping for OpenAI

package/dist/src/pricing.llm.js

@@ -22,6 +22,7 @@ exports.modelPricing = {
     "gpt-4o-mini-search-preview": { input: 0.0000015, cachedInput: 0.00000075, output: 0.000006 },
     // GPT-5 family
     "gpt-5": { input: 0.00000125, output: 0.00001 },
+    "gpt-5.1": { input: 0.00000125, output: 0.00001 },
     "gpt-5-mini": { input: 0.00000025, output: 0.000002 },
     "gpt-5-nano": { input: 0.00000005, output: 0.0000004 },
     "o1": { input: 0.000015, cachedInput: 0.0000075, output: 0.00006 },
@@ -62,10 +63,14 @@ function accumulateCost(currentUsage, model, usage) {
 // depending on the API source, return the correct mapping between ALIAS and destination models and options.
 // - LOW-fast: openai => gpt-5-nano, xAI => grok-4-nano
 // - etc.
-function LLM(openai) {
+function LLM(openai, forceThinking) {
     //
-    // Detect provider based on baseURL
+    // Detect provider based on baseURL  
     const mapping = openai?.baseURL ? LLMmapping[openai?.baseURL] : LLMmapping["default"];
+    // FIXME: this is a temporary solution to force reasoning effort to high if thinking is enabled
+    if (mapping.reasoning_effort && forceThinking) {
+        mapping.reasoning_effort = "high";
+    }
     return mapping;
 }
 exports.LLMxai = {
@@ -79,6 +84,11 @@ exports.LLMxai = {
         model: "grok-4-fast-non-reasoning", // Fast non-reasoning model
         stream: true
     },
+    "LOW-medium": {
+        temperature: 0.2,
+        model: "grok-4-fast-non-reasoning", // Fast non-reasoning model
+        stream: true
+    },
     "MEDIUM-fast": {
         temperature: 0.2,
         model: "grok-4-fast-reasoning", // Fast reasoning model
@@ -151,20 +161,20 @@ exports.LLMopenai = {
         frequency_penalty: 0.0,
         presence_penalty: 0.0,
         model: "gpt-5-nano",
-        reasoning_effort: "medium",
+        reasoning_effort: "low",
         verbosity: "low",
         stream: true
     },
-    "MEDIUM-fast": {
+    "LOW-medium": {
         temperature: 1,
         frequency_penalty: 0.0,
         presence_penalty: 0.0,
-        model: "gpt-5-mini",
-        reasoning_effort: "minimal",
+        model: "gpt-5-nano",
+        reasoning_effort: "medium",
         verbosity: "low",
         stream: true
     },
-    "LOW-4.1": {
+    "LOW-4fast": {
         temperature: .2,
         frequency_penalty: 0.0,
         presence_penalty: 0.0,
@@ -185,6 +195,15 @@ exports.LLMopenai = {
         model: "gpt-4.1",
         stream: true
     },
+    "MEDIUM-fast": {
+        temperature: 1,
+        frequency_penalty: 0.0,
+        presence_penalty: 0.0,
+        model: "gpt-5-mini",
+        reasoning_effort: "minimal",
+        verbosity: "low",
+        stream: true
+    },
     "MEDIUM": {
         temperature: 1,
         frequency_penalty: 0.0,
@@ -195,14 +214,14 @@ exports.LLMopenai = {
         stream: true
     },
     "HIGH-fast": {
-        model: "gpt-5",
-        reasoning_effort: "minimal",
+        model: "gpt-5.1",
+        reasoning_effort: "none",
         verbosity: "low",
         temperature: 1,
         stream: true
     },
-    "HIGH-low": {
-        model: "gpt-5",
+    "HIGH": {
+        model: "gpt-5.1",
         reasoning_effort: "low",
         verbosity: "low",
         stream: true
@@ -214,17 +233,19 @@ exports.LLMopenai = {
         stream: true
     },
     "SEARCH": {
-        model: "gpt-4o-mini-search-preview",
-        web_search_options: {
-            user_location: {
-                type: "approximate",
-                approximate: {
+        model: "gpt-5-mini",
+        reasoning: { effort: "low" },
+        tools: [
+            {
+                type: "web_search_preview",
+                user_location: {
+                    type: "approximate",
                     country: "CH",
                     city: "Geneva",
                     region: "Geneva",
                 },
-            },
-        },
+            }
+        ],
     },
 };
 const LLMmapping = {

package/dist/src/rag/embeddings.js

@@ -190,25 +190,31 @@ class Embeddings {
         // Sauvegarder l'ancienne config pour rollback en cas d'erreur
         const oldConfig = this.config;
         const oldVectorsFile = this.vectorsFile;
+        console.log(`\n   🔧 Embeddings.update() appelé`);
+        console.log(`      Ancien baseDir: ${oldConfig.baseDir}`);
+        console.log(`      Nouveau baseDir: ${newConfig.baseDir}`);
         try {
             // Mettre à jour la configuration
             this.config = newConfig;
             this.vectorsFile = path_1.default.join(newConfig.baseDir, types_1.RAG_FILES.VECTORS);
             this.space = newConfig.dimensions || 1536;
             this.distance = newConfig.distance || 'cosine';
+            console.log(`      Nouveau vectorsFile: ${this.vectorsFile}`);
+            console.log(`      Fichier existe: ${(0, fs_1.existsSync)(this.vectorsFile)}`);
             // Recharger l'index si ce n'est pas en mode inmemory
             if (!this.inmemory) {
                 // Vérifier que les fichiers existent
                 if (!(0, fs_1.existsSync)(this.vectorsFile)) {
                     throw new Error(`Fichier d'index manquant: ${this.vectorsFile}`);
                 }
+                console.log(`      📥 Rechargement de l'index...`);
                 // Recharger l'index
                 this.loadIndex();
+                console.log(`      📥 Rechargement des métadonnées et mapping...`);
                 // Recharger les métadonnées et le mapping
                 this.loadMetadata();
                 this.loadMapping();
-                if (this.debug)
-                    console.log(`✅ Embedding mis à jour avec nouvelle config: ${newConfig.baseDir}`);
+                console.log(`      ✅ Embedding mis à jour avec nouvelle config: ${newConfig.baseDir}`);
             }
         }
         catch (error) {

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

@@ -231,31 +231,40 @@ class RAGManager {
      */
     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) {
-            if (this.config.verbose)
-                console.log(`ℹ️ Aucun embedding chargé pour '${name}'`);
+            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 {
-            // Charger la nouvelle configuration
-            const entry = this.getEntry(name);
-            if (!entry) {
-                throw new Error(`RAG '${name}' n'existe plus dans le registre`);
-            }
             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
-            // Pour l'instant, on appelle update() directement
+            // 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);
-            if (this.config.verbose) {
-                const action = opts?.action === 'rename'
-                    ? `rename ${opts.oldFile} → ${opts.newFile}`
-                    : 'rebuild';
-                console.log(`✅ Embedding '${name}' notifié de la mise à jour (${action})`);
-            }
+            // 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 notification d'update pour '${name}':`, 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
         }
     }
@@ -777,6 +786,9 @@ class RAGManager {
             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);
         }

package/dist/src/rules/git/git.e2e.helper.js

@@ -82,15 +82,34 @@ class GitE2EHelper {
             await fs_1.promises.mkdir(uploadDir, { recursive: true });
             // Initialiser le repository Git
             await this.git.init();
+            // FIXME: remove this hack that wait for the .git directory to be created
+            // ✅ Attendre que le répertoire .git soit complètement créé
+            const gitDir = (0, path_1.join)(this.tempRepoPath, '.git');
+            // let attempts = 0;
+            // while (!existsSync(gitDir) && attempts < 50) {
+            //   await new Promise(resolve => setTimeout(resolve, 10));
+            //   attempts++;
+            // }
+            if (!(0, fs_1.existsSync)(gitDir)) {
+                throw new Error('.git directory not created after git init');
+            }
             // Configuration Git de base
             await this.git.addConfig('user.name', 'E2E Test');
             await this.git.addConfig('user.email', 'e2e@test.com');
             await this.git.addConfig('init.defaultBranch', this.config.mainBranch);
             // Créer la branche main directement
             await this.git.checkout(['-b', this.config.mainBranch]);
-            // Créer un commit initial
+            // Créer un commit initial avec un README.md valide (avec front-matter pour les tests withID)
             const readmePath = (0, path_1.join)(this.tempRepoPath, 'README.md');
-            await fs_1.promises.writeFile(readmePath, '# E2E Test Repository\n\nTemporary repository for E2E testing.');
+            const readmeContent = `---
+id: 1000
+title: E2E Test Repository
+---
+
+# E2E Test Repository
+
+Temporary repository for E2E testing.`;
+            await fs_1.promises.writeFile(readmePath, readmeContent);
             await this.git.add('README.md');
             await this.git.commit('Initial commit');
             // Créer la branche draft à partir de main

package/dist/src/rules/git/git.health.d.ts

@@ -1,4 +1,4 @@
-import { RulesGitConfig, GitHealthStatus } from '../types';
+import { RulesGitConfig, GitHealthStatus, GitPrNoteMigrationReport } from '../types';
 /**
  * Rapport d'analyse des IDs
  */
@@ -73,8 +73,10 @@ export declare class GitHealthManager {
      * - Notes orphelines sur anciens commits → copie vers HEAD + suppression
      * - Branches sans historique de notes → ignore silencieusement
      * - Erreurs de traitement par branche → continue avec les autres
+     *
+     * @returns GitPrNoteMigrationReport avec le nombre de notes migrées, déjà OK, et perdues
      */
-    migrateNotes(): Promise<void>;
+    migrateNotes(): Promise<GitPrNoteMigrationReport>;
     /**
      * Analyse les IDs des documents Markdown dans une branche
      *

package/dist/src/rules/git/git.health.js

@@ -31,8 +31,7 @@ class GitHealthManager {
             await this.git.checkout(branch);
         }
         catch (checkoutError) {
-            // Si checkout normal échoue, forcer le checkout
-            console.log(`🔧 Checkout forcé vers ${branch}...`, checkoutError);
+            // Si checkout normal échoue, continuer (forceRepair gérera l'erreur)
         }
         try {
             // Use the robust health diagnostic function
@@ -142,12 +141,14 @@ class GitHealthManager {
             const draftHealth = await (0, git_1.gitGetBranchHealth)(this.git, draftBranch);
             results.push(draftHealth);
             this.displayHealthSummary(draftHealth);
-            // Check all validation branches
+            // Check all validation branches with optimized function
             const allBranches = await (0, git_1.gitGetAllBranches)(this.git);
             const validationBranches = allBranches.filter(b => b.startsWith(validationPrefix));
             if (validationBranches.length > 0) {
+                console.log(`🔍 Diagnostic optimisé de ${validationBranches.length} branche(s) de validation...`);
                 for (const branch of validationBranches) {
-                    const health = await (0, git_1.gitGetBranchHealth)(this.git, branch);
+                    // ✅ OPTIMISATION: Utiliser la version légère pour les validations
+                    const health = await (0, git_1.gitGetValidationBranchHealth)(this.git, branch, this.config);
                     results.push(health);
                     this.displayHealthSummary(health);
                 }
@@ -294,20 +295,23 @@ class GitHealthManager {
      * - Notes orphelines sur anciens commits → copie vers HEAD + suppression
      * - Branches sans historique de notes → ignore silencieusement
      * - Erreurs de traitement par branche → continue avec les autres
+     *
+     * @returns GitPrNoteMigrationReport avec le nombre de notes migrées, déjà OK, et perdues
      */
     async migrateNotes() {
         const { mainBranch, validationPrefix, gitNotes } = this.config;
         if (!validationPrefix || !gitNotes.namespace) {
             console.error("Erreur: Le préfixe de validation ou le namespace des notes n'est pas configuré.");
-            return;
+            return { migrated: 0, alreadyOk: 0, lost: [] };
         }
         const allBranches = await (0, git_1.gitGetAllBranches)(this.git);
         const validationBranches = allBranches.filter(b => b.startsWith(validationPrefix));
         if (validationBranches.length === 0) {
-            return;
+            return { migrated: 0, alreadyOk: 0, lost: [] };
         }
         let migratedCount = 0;
         let alreadyOkCount = 0;
+        const lostNotes = [];
         for (const branch of validationBranches) {
             try {
                 const lastCommit = (await this.git.revparse(branch)).trim();
@@ -325,12 +329,20 @@ class GitHealthManager {
                 }
                 const revListOutput = await this.git.raw('rev-list', `${mergeBase}..${branch}`);
                 const branchCommits = revListOutput.split('\n').filter(Boolean);
+                // Extract PR number from branch name (e.g., rule-validation-31 -> 31)
+                const prNumber = parseInt(branch.split('-').pop() || '0', 10);
                 let oldNoteCommit = null;
                 for (const commitHash of branchCommits) {
                     const note = await (0, git_1.gitReadNote)(this.git, commitHash, gitNotes.namespace, 1);
                     if (note) {
-                        oldNoteCommit = commitHash;
-                        break; // Found the first note, stop searching
+                        // CRITICAL FIX: Verify the note belongs to this PR before migrating
+                        if (note.id === prNumber) {
+                            oldNoteCommit = commitHash;
+                            break; // Found the correct note for this PR
+                        }
+                        else {
+                            console.log(`   ⚠️  ${branch}: Note trouvée avec ID=${note.id}, attendu ID=${prNumber} - ignorée`);
+                        }
                     }
                 }
                 // 3. If a note was found on an old commit, migrate it
@@ -341,6 +353,11 @@ class GitHealthManager {
                     console.log(`✅ ${branch}: Migration terminée`);
                     migratedCount++;
                 }
+                else {
+                    // CRITICAL: Note perdue pour cette validation
+                    console.error(`🚨 ${branch}: NOTE PERDUE - PR ${prNumber} n'a plus de note dans son historique`);
+                    lostNotes.push({ branch, prNumber });
+                }
             }
             catch (error) {
                 console.error(`❌ ${branch}: Erreur lors de la migration:`, error);
@@ -348,9 +365,14 @@ class GitHealthManager {
             }
         }
         // Summary only if there was work to do
-        if (migratedCount > 0 || alreadyOkCount !== validationBranches.length) {
-            console.log(`✅ Migration des notes terminée: ${migratedCount} migrées, ${alreadyOkCount} déjà OK`);
+        if (migratedCount > 0 || alreadyOkCount !== validationBranches.length || lostNotes.length > 0) {
+            console.log(`✅ Migration des notes terminée: ${migratedCount} migrées, ${alreadyOkCount} déjà OK${lostNotes.length > 0 ? `, ${lostNotes.length} perdues 🚨` : ''}`);
         }
+        return {
+            migrated: migratedCount,
+            alreadyOk: alreadyOkCount,
+            lost: lostNotes
+        };
     }
     /**
      * Analyse les IDs des documents Markdown dans une branche
@@ -428,9 +450,9 @@ class GitHealthManager {
                             else {
                                 hasValidID = true;
                                 // Enregistrer l'ID existant dans le registry
-                                // ✅ Passer branch et file pour vérifier si l'ID appartient au même fichier
+                                // ✅ gitRegisterExistingID() appelle maintenant setMatterCache() automatiquement si matter est fourni
                                 try {
-                                    (0, git_1.gitRegisterExistingID)(matter.id, branchName, file, this.config);
+                                    (0, git_1.gitRegisterExistingID)(matter, branchName, file, this.config);
                                 }
                                 catch (error) {
                                     if (error.code === 'id_already_used') {
@@ -548,9 +570,25 @@ class GitHealthManager {
                     // Parser le matter complet
                     const parsed = (0, utils_matter_1.matterParse)(fileData.content);
                     const { matter: fullMatter, content } = parsed;
-                    // Générer un nouvel ID
-                    fullMatter.id = (0, git_1.gitGenerateNextID)(this.config);
-                    console.log(`   🔧 ${file}: Génération d'un nouvel ID: ${fullMatter.id}`);
+                    // Générer un nouvel ID si manquant
+                    if (!fullMatter.id || typeof fullMatter.id !== 'number' || fullMatter.id <= 999) {
+                        fullMatter.id = (0, git_1.gitGenerateNextID)(this.config);
+                        console.log(`   🔧 ${file}: Génération d'un nouvel ID: ${fullMatter.id}`);
+                    }
+                    // Générer un titre si manquant (basé sur le nom du fichier ou le premier titre de section)
+                    if (!fullMatter.title || fullMatter.title.trim() === '') {
+                        // Essayer d'extraire le premier titre de section (# Title)
+                        const titleMatch = content.match(/^#\s+(.+)$/m);
+                        if (titleMatch) {
+                            fullMatter.title = titleMatch[1].trim();
+                        }
+                        else {
+                            // Sinon, utiliser le nom du fichier sans extension
+                            const fileName = file.replace(/\.md$/, '').replace(/[-_]/g, ' ');
+                            fullMatter.title = fileName.split(' ').map(w => w.charAt(0).toUpperCase() + w.slice(1)).join(' ');
+                        }
+                        console.log(`   🔧 ${file}: Génération d'un titre: ${fullMatter.title}`);
+                    }
                     // Re-sérialiser et sauvegarder
                     const updatedContent = (0, utils_matter_1.matterSerialize)(content, fullMatter);
                     // ✅ IMPORTANT: Désactiver withID car l'ID est déjà généré et enregistré
@@ -618,6 +656,10 @@ class GitHealthManager {
         if (autoFix && (report.missingID.length > 0 || report.missingTitle.length > 0 || report.invalidID.length > 0 || report.duplicateID.length > 0)) {
             finalReport = await this.repairSafeIDs(report, { dryRun });
         }
+        // Calculer le nombre de fichiers réparés
+        // C'est la différence entre les problèmes avant et après réparation
+        const fixed = (report.missingID.length + report.missingTitle.length + report.invalidID.length + report.duplicateID.length) -
+            (finalReport.missingID.length + finalReport.missingTitle.length + finalReport.invalidID.length + finalReport.duplicateID.length);
         // Retourner dans l'ancien format pour compatibilité
         return {
             scanned: finalReport.scanned,
@@ -626,7 +668,7 @@ class GitHealthManager {
             missingTitle: finalReport.missingTitle.length,
             invalidID: finalReport.invalidID.length,
             duplicateID: finalReport.duplicateID.length,
-            fixed: report.scanned - finalReport.scanned + finalReport.valid - report.valid,
+            fixed: Math.max(0, fixed), // S'assurer que fixed n'est pas négatif
             errors: finalReport.errors
         };
     }

package/dist/src/rules/git/index.d.ts

@@ -1,5 +1,5 @@
 export { lock, unlock, gitLoad, isValidInt, gitIsFileMerged, gitLastCommit, gitListFilesInBranch, gitListFilesOutsideRepo, gitFileExistsInBranch, gitGetFilesSummary, gitGetFileContent, gitGetFilePreview, gitGetFileHistory, gitReadFileOutsideRepo, gitGetUnmergedBranchesForFile, gitGetAllBranches, gitGetDiffFiles, gitReadNote, gitWriteNote, gitDeleteNote, } from './repo.tools';
-export { gitInit, gitEnsureRepositoryConfiguration, gitEnsureRemoteConfiguration, gitSetupRepository, gitShowConfiguration, gitCheckConfiguration, gitGetBranchHealth, gitCreateOrEditFile, gitEditFile, gitRenameFile, gitDeleteFile, gitGenerateNextID, gitReloadIDRegistry, gitRegisterExistingID, gitEnsureMatterID, gitFileStrictMatter, gitIDRegistryExists, gitIDRegistryRename, } from './repo';
+export { gitInit, gitEnsureRepositoryConfiguration, gitEnsureRemoteConfiguration, gitSetupRepository, gitShowConfiguration, gitCheckConfiguration, gitGetBranchHealth, gitGetValidationBranchHealth, gitCreateOrEditFile, gitEditFile, gitRenameFile, gitDeleteFile, gitGenerateNextID, gitReloadIDRegistry, gitRegisterExistingID, gitEnsureMatterID, gitFileStrictMatter, gitIDRegistryExists, gitIDRegistryRename, } from './repo';
 export { gitSyncPR, gitIsPRClosed, gitIsPRClosedRobust, gitGetPRMetadata, gitGetAllPR, gitGetClosedPRs, gitLoadPR, gitPRUpdateComments, gitClosePR, gitClosePRRobust, gitGetNextPRNumber, gitNewValidationRequest, gitNewPR, } from './repo.pr';
 export * from './git.e2e.helper';
 export * from './git.health';