agentic-api 1.0.6 → 2.0.31

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

@@ -0,0 +1,730 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lock = lock;
+exports.unlock = unlock;
+exports.gitLoad = gitLoad;
+exports.gitGetFilePreview = gitGetFilePreview;
+exports.gitGetFileContent = gitGetFileContent;
+exports.gitReadFileOutsideRepo = gitReadFileOutsideRepo;
+exports.gitGetFileHistory = gitGetFileHistory;
+exports.gitLastCommit = gitLastCommit;
+exports.gitListFilesInBranch = gitListFilesInBranch;
+exports.gitListFilesOutsideRepo = gitListFilesOutsideRepo;
+exports.gitFileExistsInBranch = gitFileExistsInBranch;
+exports.gitGetUnmergedBranchesForFile = gitGetUnmergedBranchesForFile;
+exports.gitIsFileMerged = gitIsFileMerged;
+exports.gitGetAllBranches = gitGetAllBranches;
+exports.gitGetDiffFiles = gitGetDiffFiles;
+exports.gitReadNote = gitReadNote;
+exports.gitWriteNote = gitWriteNote;
+exports.gitDeleteNote = gitDeleteNote;
+exports.gitGetFilesSummary = gitGetFilesSummary;
+const simple_git_1 = require("simple-git");
+const messages_1 = require("../messages");
+const fs_1 = require("fs");
+const errors_1 = require("../errors");
+const path_1 = require("path");
+const fs = __importStar(require("fs/promises"));
+const async_mutex_1 = require("async-mutex");
+// Global map to hold mutexes for different resources
+const mutexes = new Map();
+const releasers = new Map();
+async function lock(key) {
+    if (!mutexes.has(key)) {
+        mutexes.set(key, new async_mutex_1.Mutex());
+    }
+    const mutex = mutexes.get(key);
+    const releaser = await mutex.acquire();
+    releasers.set(key, releaser);
+}
+function unlock(key) {
+    if (releasers.has(key)) {
+        releasers.get(key)(); // Execute the release function
+        releasers.delete(key);
+    }
+}
+// Global variables for git config and instance
+let gitConfig;
+let git;
+/**
+ * Configuration et initialisation du client Git
+ * @returns Configuration Git avec l'instance et les chemins
+ */
+function gitLoad(defaultConfig) {
+    if (gitConfig && !defaultConfig?.reset) {
+        return { ...gitConfig, ...(defaultConfig || {}) };
+    }
+    // console.log(`🌶️ gitLoad: First Loading git config`,defaultConfig);
+    const verbose = defaultConfig?.verbose || process.env.GIT_VERBOSE === 'true';
+    const remoteUrl = defaultConfig?.remoteUrl || process.env.GIT_REMOTE_URL;
+    const repoPath = defaultConfig?.repoPath || process.env.GIT_REPO_PATH;
+    const uploadPath = defaultConfig?.uploadPath || process.env.GIT_UPLOAD_PATH;
+    const draftBranch = defaultConfig?.draftBranch || process.env.DEFAULT_BRANCH_DRAFT;
+    const mainBranch = defaultConfig?.mainBranch || process.env.DEFAULT_BRANCH_MAIN;
+    const validationPrefix = defaultConfig?.validationPrefix || process.env.DEFAULT_BRANCH_VALIDATION_PREFIX;
+    const releasePrefix = defaultConfig?.releasePrefix || process.env.DEFAULT_BRANCH_RELEASE_PREFIX;
+    const validationToken = defaultConfig?.validationToken || process.env.DEFAULT_VALIDATION_TOKEN;
+    const sshKeyPath = process.env.GIT_SSH_KEY_PATH;
+    const sshPassphrase = process.env.GIT_SSH_PASSPHRASE;
+    if (!repoPath || !draftBranch || !uploadPath || !mainBranch || !validationToken) {
+        throw new errors_1.GitConfigurationError(messages_1.i18nRules.git_config_incomplete, 'repoPath|draftBranch|uploadPath|mainBranch|validationToken');
+    }
+    // Ensure the repository directory exists
+    if (!(0, fs_1.existsSync)(repoPath)) {
+        if (defaultConfig?.verbose)
+            console.log(`Creating repository directory: ${repoPath}`);
+        (0, fs_1.mkdirSync)(repoPath, { recursive: true });
+    }
+    // Ensure the repository directory exists
+    if (!(0, fs_1.existsSync)(uploadPath)) {
+        if (defaultConfig?.verbose)
+            console.log(`Creating upload directory: ${uploadPath}`);
+        (0, fs_1.mkdirSync)(uploadPath, { recursive: true });
+    }
+    // Configuration SSH si nécessaire
+    const gitOptions = { baseDir: repoPath, binary: 'git' };
+    if (sshKeyPath) {
+        gitOptions.config = {
+            'core.sshCommand': `ssh -i ${sshKeyPath}${sshPassphrase ? ` -N` : ''}`
+        };
+    }
+    const gitInstance = (0, simple_git_1.simpleGit)(gitOptions);
+    // Configuration de la branche principale par défaut
+    if (gitInstance?.addConfig) {
+        gitInstance.addConfig('init.defaultBranch', mainBranch);
+    }
+    // Configuration de la concurrence
+    const concurrency = {
+        maxRetries: parseInt(process.env.GIT_CONCURRENCY_MAX_RETRIES || '3', 10),
+        retryDelayMs: parseInt(process.env.GIT_CONCURRENCY_RETRY_DELAY_MS || '100', 10),
+        timeoutMs: parseInt(process.env.GIT_CONCURRENCY_TIMEOUT_MS || '5000', 10)
+    };
+    // Configuration des Git Notes
+    const gitNotes = {
+        namespace: process.env.GIT_NOTES_NAMESPACE || 'refs/notes/pr-status',
+        enabled: process.env.GIT_NOTES_ENABLED !== 'false', // Activé par défaut
+        fallbackToCommit: process.env.GIT_NOTES_FALLBACK_TO_COMMIT !== 'false' // Activé par défaut
+    };
+    gitConfig = {
+        instance: gitInstance,
+        repoPath,
+        uploadPath,
+        draftBranch,
+        mainBranch,
+        validationPrefix: validationPrefix || 'rule-validation-',
+        releasePrefix: releasePrefix || 'rule-release-',
+        validationToken: validationToken || 'closed',
+        concurrency,
+        gitNotes,
+        remoteUrl,
+        verbose,
+        canForce: defaultConfig?.canForce,
+        reset: defaultConfig?.reset
+    };
+    git = gitInstance;
+    return gitConfig;
+}
+/**
+ * Récupère la prévisualisation d'un fichier depuis Git (opération bas niveau atomique),
+ * sans les métadonnées.
+ * @param git Instance SimpleGit
+ * @param filename Nom du fichier
+ * @param branch Branche optionnelle (par défaut: rule-editor)
+ * @returns Contenu du fichier ou null si non trouvé
+ */
+async function gitGetFilePreview(git, filename, branch = 'rule-editor', fallback = false) {
+    const gitConfig = gitLoad();
+    // FIXME missing test for branch NEW
+    // Fast-path: NEW files are stored outside the repo. Read directly from filesystem.
+    if (branch?.toLowerCase() === 'new') {
+        try {
+            const { content } = await gitReadFileOutsideRepo(git, filename);
+            return content;
+        }
+        catch (error) {
+            if (!fallback)
+                return null;
+        }
+    }
+    if (branch.startsWith(gitConfig.validationPrefix)) {
+        try {
+            const parse = (await git.raw(['rev-list', '--reverse', branch, '--', filename])).split('\n').map(hash => hash.trim()).filter(hash => hash.length);
+            // Vérifier si branch est un hash de commit (40 caractères hexadécimaux) ou une branche
+            const hash = parse[0];
+            const content = await git.show([`${hash}:${filename}`]);
+            return content;
+        }
+        catch (error) {
+            console.log('🌶️ gitGetFilePreview', `${branch}:${filename}`, error.message);
+            // try other solutions
+            if (!fallback) {
+                return null;
+            }
+        }
+    }
+    try {
+        // 1. Récupération atomique du contenu
+        const showRef = `${branch}:${filename}`;
+        const contents = await git.show([showRef]);
+        return contents;
+    }
+    catch (error) {
+    }
+    try {
+        // 0. Check if branch is NEW
+        const { content, date } = await gitReadFileOutsideRepo(git, filename);
+        return content;
+    }
+    catch (error) {
+    }
+    return null;
+}
+/**
+ * Récupère le contenu d'un fichier depuis Git (opération bas niveau atomique),
+ * ainsi que les métadonnées du dernier commit qui a touché ce fichier dans la même branche.
+ * @param git Instance SimpleGit
+ * @param filename Chemin du fichier
+ * @param branch Branche optionnelle (par défaut: HEAD)
+ * @returns Contenu du fichier avec métadonnées ou null si non trouvé
+ */
+async function gitGetFileContent(git, filename, branch = 'HEAD') {
+    try {
+        // 0. Check if branch is NEW
+        if (branch?.toLocaleLowerCase() === 'new') {
+            const { content, date } = await gitReadFileOutsideRepo(git, filename);
+            return {
+                hash: 'NEW',
+                date,
+                message: '',
+                author: { name: 'system', email: 'system' },
+                content,
+                branch: 'NEW'
+            };
+        }
+        // 1. Récupération atomique du contenu
+        const showRef = `${branch}:${filename}`;
+        const content = await git.show([showRef]);
+        const log = await git.log(['-n', '1', branch, '--', filename]);
+        const commit = log.latest;
+        //console.log('🌶️ gitGetFileContent', {filename, branch, commit});
+        if (!commit) {
+            return null;
+        }
+        return {
+            hash: commit.hash,
+            date: new Date(commit.date),
+            message: commit.message,
+            author: {
+                name: commit.author_name,
+                email: commit.author_email
+            },
+            content: content,
+            branch
+        };
+    }
+    catch (error) {
+        // Si le fichier n'existe pas dans la branche donnée, git.show ou git.log lève une erreur
+        const msg = error.message;
+        if (msg.includes('does not exist') || msg.includes('fatal: Path')) {
+            return null;
+        }
+        // Autres erreurs : on remonte (TODO for next release)
+        // throw error;
+        return null;
+    }
+}
+/**
+ * FIXME:missing return type
+ * Lit le contenu d'un fichier depuis le système de fichiers (hors repo ou dans uploadPath)
+ * @param filePath Chemin du fichier
+ * @returns Contenu du fichier ou null si non trouvé
+ */
+async function gitReadFileOutsideRepo(git, filePath) {
+    const gitConfig = gitLoad();
+    const uploadPath = gitConfig.uploadPath;
+    const fullPath = (0, path_1.join)(uploadPath, filePath);
+    try {
+        const stats = await fs.stat(fullPath);
+        const date = stats.mtime;
+        const content = await fs.readFile(fullPath, 'utf-8');
+        return { content, date };
+    }
+    catch (error) {
+        // if (error.code === 'ENOENT') {
+        //   return null;
+        // }
+        throw error;
+    }
+}
+async function gitGetFileHistory(git, filename, hash) {
+    try {
+        const log = await git.log({ file: filename });
+        const all = log.all.map(commit => ({
+            hash: commit.hash,
+            date: new Date(commit.date),
+            message: commit.message,
+            author: {
+                name: commit.author_name,
+                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);
+            if (index !== -1 && fileContent) {
+                all[index] = fileContent;
+            }
+        }
+        return all;
+    }
+    catch (error) {
+        throw new errors_1.GitOperationError(`Failed to get file history for ${filename}: ${error}`, 'file_history_get', { filename, error });
+    }
+}
+/**
+ * Récupère le dernier commit d'une branche (opération bas niveau atomique)
+ * @param git Instance SimpleGit
+ * @param branch Nom de la branche
+ * @returns Dernier commit de la branche ou null si la branche n'existe pas
+ */
+async function gitLastCommit(git, branch) {
+    try {
+        const log = await git.log({ from: branch, to: branch, maxCount: 1 });
+        const commit = log.latest;
+        if (!commit) {
+            return null;
+        }
+        return {
+            hash: commit.hash,
+            date: new Date(commit.date),
+            message: commit.message,
+            author: {
+                name: commit.author_name,
+                email: commit.author_email
+            },
+            branch
+        };
+    }
+    catch (error) {
+        throw new errors_1.GitOperationError(`Failed to get last commit for branch ${branch}: ${error}`, 'last_commit_get', { branch, error });
+    }
+}
+/**
+ * Liste tous les fichiers d'un type donné dans une branche (opération bas niveau atomique)
+ * @param git Instance Git
+ * @param branch Nom de la branche à lister
+ * @param pattern Pattern de fichiers (ex:'.md')
+ * @returns Liste des chemins de fichiers
+ */
+async function gitListFilesInBranch(git, branch, ext = '.md') {
+    try {
+        // Utilisation atomique de ls-tree sans checkout
+        const output = await git.raw(['ls-tree', '-r', '--name-only', branch]);
+        const allFiles = output.split('\n').filter(Boolean);
+        // Filtrer selon le pattern (simple matching pour *.md)
+        return allFiles.filter(file => file.endsWith(ext));
+    }
+    catch (error) {
+        throw new errors_1.BranchNotFoundError(branch);
+    }
+}
+async function gitListFilesOutsideRepo(git, options = {}) {
+    try {
+        const gitConfig = gitLoad();
+        const { ext = '.md' } = options;
+        const uploadPath = gitConfig.uploadPath; // Chemin absolu
+        const files = [];
+        // List files from upload directory using fs.readdir
+        try {
+            const uploadFiles = await fs.readdir(uploadPath);
+            for (const fileName of uploadFiles) {
+                if (!ext || fileName.endsWith(ext)) {
+                    try {
+                        const fullPath = (0, path_1.join)(uploadPath, fileName);
+                        const stats = await fs.stat(fullPath);
+                        files.push({ file: fileName, path: fullPath, date: stats.mtime });
+                    }
+                    catch (statError) {
+                        if (gitConfig.verbose) {
+                            console.warn(`🌶️ DEBUG: gitListFilesOutsideRepo -- Impossible de lire les stats du fichier ${fileName} dans ${uploadPath}, ignoré. Erreur: ${statError}`);
+                        }
+                    }
+                }
+            }
+        }
+        catch (error) {
+            if (gitConfig.verbose) {
+                console.warn(`🌶️ DEBUG: gitListFilesOutsideRepo -- Impossible d'accéder au répertoire ${uploadPath}: ${error}`);
+            }
+        }
+        return files;
+    }
+    catch (error) {
+        throw new errors_1.GitOperationError(`Failed to list files outside repo: ${error}`, 'gitListFilesOutsideRepo', { error });
+    }
+}
+/**
+ * Vérifie si un fichier existe dans une branche donnée et s'il est plus récent que la version dans main
+ * @param git Instance Git
+ * @param filePath Chemin du fichier
+ * @param branch Branche à vérifier
+ * @param config Configuration Git (optionnel, utilise la config globale)
+ * @returns true si le fichier existe et est plus récent que main
+ */
+async function gitFileExistsInBranch(git, filePath, branch = 'HEAD', config) {
+    const gitConfig = gitLoad();
+    try {
+        //
+        // If file does not exist, git.raw will throw an error
+        const showRef = `${branch.toString()}:${filePath}`;
+        await git.raw(['cat-file', '-e', showRef]);
+        // const out = await git.raw(['ls-tree', '-r', '--name-only', branch, '--', filePath]);
+        // console.log('🌶️ DEBUG: gitFileExistsInBranch:', { showRef, out });
+        return true;
+    }
+    catch (error) {
+        if (/does not exist/.test(error.message)) {
+            return false;
+        }
+        if (/exists on disk, but not in/.test(error.message)) {
+            return false;
+        }
+        if (gitConfig.verbose)
+            console.log('🌶️ DEBUG: gitFileExistsInBranch:', error);
+        return false;
+    }
+}
+/**
+ * Retourne la liste des branches non mergées contenant un fichier spécifique
+ * @param git Instance Git
+ * @param filePath Chemin du fichier
+ * @param targetBranch Branche cible (par défaut: main)
+ * @returns Liste des branches non mergées contenant le fichier
+ */
+async function gitGetUnmergedBranchesForFile(git, filePath, targetBranch = 'main') {
+    try {
+        // 1. Obtenir toutes les branches non mergées
+        const unmergedBranches = await gitGetAllBranches(git, {
+            unmergedOnly: true,
+            mainBranch: targetBranch
+        });
+        // 2. Filtrer les branches qui contiennent le fichier
+        const branchesWithFile = [];
+        for (const branch of unmergedBranches) {
+            const exists = await gitFileExistsInBranch(git, filePath, branch);
+            if (exists) {
+                branchesWithFile.push(branch);
+            }
+        }
+        return branchesWithFile;
+    }
+    catch (error) {
+        throw new errors_1.GitOperationError(`Failed to get unmerged branches for file ${filePath}: ${error}`, 'unmerged_branches_for_file', { filePath, targetBranch, error });
+    }
+}
+/**
+ * Vérifie si la dernière version du fichier (sur sourceBranch) a été mergée dans targetBranch.
+ * - Recherche du dernier commit modifiant filePath sur sourceBranch
+ * - Test de l'ancêtre (merge-base --is-ancestor)
+ */
+async function gitIsFileMerged(git, filePath, from, target = 'main') {
+    const gitConfig = gitLoad();
+    try {
+        // 0. Vérification rapide : si la branche source est mergée, le fichier l'est aussi
+        const unmergedBranches = await gitGetAllBranches(git, { unmergedOnly: true, mainBranch: target });
+        if (!unmergedBranches.includes(from)) {
+            return true; // La branche est mergée, donc le fichier aussi
+        }
+        // 1. Récupérer le dernier commit qui a touché le fichier dans la branche source
+        const commitHash = await git.raw(['log', from, '--', filePath, '-1', '--format=%H']);
+        const hash = commitHash.trim();
+        if (!hash) {
+            return false;
+        }
+        // 2. Récupérer le dernier commit qui a touché le fichier dans la branche cible
+        const lastMain = await git.raw(['log', target, '--', filePath, '-1', '--format=%H']);
+        const mainHash = lastMain.trim();
+        // 3. Si les commits sont identiques, c'est un merge fast-forward réussi
+        if (hash === mainHash) {
+            return true;
+        }
+        // 4. Sinon, vérifier si le commit est ancestor de targetBranch
+        try {
+            await git.raw(['merge-base', '--is-ancestor', hash, target]);
+            return true; // code de sortie 0 => mergé
+        }
+        catch (error) {
+            return false; // non-ancêtre => pas mergé
+        }
+    }
+    catch (error) {
+        if (gitConfig.verbose)
+            console.warn(`🌶️ DBG ---- Erreur lors de la vérification du merge de ${filePath}:`, error);
+        return false;
+    }
+}
+/**
+ * Récupère la liste de toutes les branches (opération bas niveau)
+ * @param git Instance Git
+ * @param options Options de filtrage des branches
+ * @returns Liste des noms de branches
+ */
+async function gitGetAllBranches(git, options = {}) {
+    try {
+        const gitConfig = gitLoad();
+        if (options.unmergedOnly) {
+            const main = options.mainBranch || gitConfig.mainBranch;
+            const output = await git.raw(['branch', '--no-merged', main]);
+            return output
+                .split('\n')
+                .map((b) => b.trim().replace('* ', ''))
+                .filter(Boolean);
+        }
+        // Sinon, retourner toutes les branches
+        const branches = await git.branchLocal();
+        return branches.all;
+    }
+    catch (error) {
+        throw new errors_1.GitOperationError(`Failed to retrieve branches: ${error}`, 'branch_listing', { originalError: error });
+    }
+}
+/**
+ * Récupère les fichiers modifiés entre deux branches (sans état)
+ * @param git Instance SimpleGit
+ * @param targetBranch Branche à comparer
+ * @param baseBranch Branche de base (par défaut: main)
+ * @param filter Filtre optionnel (ex: '.md')
+ * @returns Liste des fichiers modifiés
+ */
+async function gitGetDiffFiles(git, targetBranch, baseBranch, filter) {
+    const gitConfig = gitLoad();
+    const base = baseBranch || gitConfig.mainBranch;
+    try {
+        // Utilise git diff --name-only pour obtenir les fichiers modifiés
+        const diffResult = await git.raw(['diff', '--name-only', `${base}...${targetBranch}`]);
+        const files = diffResult
+            .split('\n')
+            .filter((file) => file.trim()) // Supprimer les lignes vides
+            .filter((file) => !filter || file.endsWith(filter)); // Appliquer le filtre si fourni
+        return files;
+    }
+    catch (error) {
+        if (gitConfig.verbose)
+            console.error(`[gitGetDiffFiles] Error getting diff between ${base} and ${targetBranch}:`, error);
+        return [];
+    }
+}
+/**
+ * Lit une note Git pour une branche donnée
+ * @param git Instance Git
+ * @param branchOrCommit Hash du commit ou nom de la branche
+ * @param namespace Namespace des notes
+ * @param maxCommits Nombre maximum de commits à examiner (défaut: 10)
+ * @returns Contenu de la note ou null si inexistante
+ */
+async function gitReadNote(git, branchOrCommit, namespace, maxCommits = 10) {
+    try {
+        // D'abord, essayer de lire directement la note sur la branche/commit
+        try {
+            const noteContent = await git.raw(['notes', '--ref', namespace, 'show', branchOrCommit]);
+            if (noteContent) {
+                return JSON.parse(noteContent.trim());
+            }
+        }
+        catch (error) {
+            // Si pas de note directement sur la branche, continuer avec l'historique
+        }
+        // Récupérer les N derniers commits de la branche
+        const log = await git.log(['-n', `${maxCommits}`, branchOrCommit]);
+        // const log = await git.log({ 
+        //   from: branchOrCommit,
+        //   to: branchOrCommit
+        // });
+        // Chercher une note dans chaque commit, du plus récent au plus ancien
+        for (const commit of log.all) {
+            try {
+                const noteContent = await git.raw(['notes', '--ref', namespace, 'show', commit.hash]);
+                if (noteContent) {
+                    return JSON.parse(noteContent.trim());
+                }
+            }
+            catch (error) {
+                // Continue avec le commit suivant si aucune note n'est trouvée
+                continue;
+            }
+        }
+        //
+        // Si aucune note trouvée dans l'historique, essayer de lister toutes les notes disponibles
+        // try {
+        //   const allNotes = await git.raw(['notes', '--ref', namespace, 'list']);
+        //   if (allNotes.trim()) {
+        //     const noteLines = allNotes.trim().split('\n');
+        //     for (const line of noteLines) {
+        //       const [noteHash, commitHash] = line.split(' ');
+        //       if (noteHash && commitHash) {
+        //         try {
+        //           const noteContent = await git.raw(['notes', '--ref', namespace, 'show', commitHash]);
+        //           if (noteContent) {
+        //             const metadata = JSON.parse(noteContent.trim());
+        //             // Vérifier si cette note correspond à notre branche
+        //             if (metadata && typeof metadata === 'object' && metadata.id) {
+        //               return metadata;
+        //             }
+        //           }
+        //         } catch(error) {
+        //           continue;
+        //         }
+        //       }
+        //     }
+        //   }
+        // } catch(error) {
+        //   // Ignorer les erreurs de listing des notes
+        // }
+        return null; // Aucune note trouvée
+    }
+    catch (error) {
+        // En cas d'erreur (branche inexistante, etc.), retourner null
+        return null;
+    }
+}
+/**
+ * Écrit une note Git pour une branche donnée
+ * @param git Instance Git
+ * @param commitHash Hash du commit
+ * @param author la note
+ * @param content Contenu de la note
+ * @param namespace Namespace des notes
+ */
+async function gitWriteNote(git, commitHash, metadata, namespace) {
+    await lock(`gitWriteNote:${commitHash}`);
+    try {
+        // Ajouter ou remplacer la note
+        const noteMetadata = {
+            ...metadata,
+            ...{ timestamp: new Date().toISOString() }
+        };
+        const content = JSON.stringify(noteMetadata, null, 2);
+        await git.raw(['notes', '--ref', namespace, 'add', '-f', '-m', content, commitHash]);
+        // console.log(`[DEBUG][gitWriteNote] Note written successfully for ${branch}. Content snippet: ${content.substring(0, 50)}...`);
+    }
+    catch (error) {
+        console.error(`[DEBUG][gitWriteNote] Error writing note for ${commitHash}:`, error);
+        throw new errors_1.GitOperationError(`Failed to write note to branch "${commitHash}": ${error}`, 'note_write', { branch: commitHash, error });
+    }
+    finally {
+        unlock(`gitWriteNote:${commitHash}`);
+    }
+}
+/**
+ * Modifie un fichier dans la branche draft (opération bas niveau)
+ * @param namespace Namespace des notes
+ */
+async function gitDeleteNote(git, commitHash, namespace) {
+    try {
+        await git.raw(['notes', '--ref', namespace, 'remove', commitHash]);
+    }
+    catch (e) {
+        // Ignore error if note does not exist
+    }
+}
+/**
+ * FIXME: GitFileSummary must be cached in memory (and refreshed on change)
+ * Retrieves a summary (content and last commit) for multiple files in a branch efficiently.
+ * It uses a single `git log` command for all files to improve performance.
+ * @param git SimpleGit instance
+ * @param branch The branch to inspect
+ * @returns An array of GitFileSummary objects.
+ */
+async function gitGetFilesSummary(git, branch) {
+    const files = await gitListFilesInBranch(git, branch, '.md');
+    if (files.length === 0) {
+        return [];
+    }
+    // 1. Get content for all files in parallel
+    const contents = await Promise.all(files.map((file) => git.show([`${branch}:${file}`]).catch(() => null)));
+    // 2. Get last commit for all files in one go using a raw log command
+    const logOutput = await git.raw([
+        'log',
+        branch,
+        '--name-only',
+        '--pretty=format:---COMMIT---%n%H%n%aN%n%aE%n%aI',
+        '--',
+        ...files
+    ]);
+    const commitsByFile = new Map();
+    if (logOutput) {
+        const commitChunks = logOutput.split('---COMMIT---\n');
+        for (const chunk of commitChunks) {
+            if (chunk.trim() === '')
+                continue;
+            const lines = chunk.trim().split('\n');
+            const [hash, authorName, authorEmail, date] = lines.slice(0, 4);
+            const changedFiles = lines.slice(4).filter(Boolean);
+            for (const file of changedFiles) {
+                if (!commitsByFile.has(file)) {
+                    commitsByFile.set(file, {
+                        hash,
+                        author: { name: authorName, email: authorEmail },
+                        date,
+                    });
+                }
+            }
+        }
+    }
+    // 3. Combine results
+    const summaries = [];
+    for (let i = 0; i < files.length; i++) {
+        const filePath = files[i];
+        const content = contents[i];
+        const commitInfo = commitsByFile.get(filePath);
+        if (content !== null && commitInfo) {
+            summaries.push({
+                filePath,
+                content,
+                commit: {
+                    hash: commitInfo.hash,
+                    date: new Date(commitInfo.date),
+                    message: '', // Not retrieved for performance, can be added if needed
+                    author: commitInfo.author,
+                    branch,
+                    content,
+                },
+            });
+        }
+    }
+    return summaries;
+}