agentic-api 1.0.6 → 2.0.31

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

@@ -0,0 +1,900 @@
+"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.gitEnsureRepositoryConfiguration = gitEnsureRepositoryConfiguration;
+exports.gitEnsureRemoteConfiguration = gitEnsureRemoteConfiguration;
+exports.gitInit = gitInit;
+exports.gitSetupRepository = gitSetupRepository;
+exports.gitShowConfiguration = gitShowConfiguration;
+exports.gitCheckConfiguration = gitCheckConfiguration;
+exports.gitCreateOrEditFile = gitCreateOrEditFile;
+exports.gitEditFile = gitEditFile;
+exports.gitRenameFile_git = gitRenameFile_git;
+exports.gitRenameFile_fs = gitRenameFile_fs;
+exports.gitRenameFile = gitRenameFile;
+exports.gitDeleteFile = gitDeleteFile;
+exports.gitGetBranchHealth = gitGetBranchHealth;
+const fs_1 = require("fs");
+const errors_1 = require("../errors");
+const path_1 = require("path");
+const fs = __importStar(require("fs/promises"));
+const repo_tools_1 = require("./repo.tools");
+/**
+ * Vérifie et configure un repository Git existant pour s'assurer qu'il a la configuration requise
+ * @param git Instance SimpleGit
+ * @param options Options de configuration
+ */
+async function gitEnsureRepositoryConfiguration(git, options = {}) {
+    const { remoteUrl = (0, repo_tools_1.gitLoad)().remoteUrl, remoteName = 'origin', forceUpdate = false } = options;
+    const changes = [];
+    try {
+        const gitConfig = (0, repo_tools_1.gitLoad)();
+        const isRepo = await git.checkIsRepo();
+        if (!isRepo) {
+            throw new errors_1.GitConfigurationError('Not a Git repository', 'repo_not_found');
+        }
+        // Vérifier la configuration de la branche par défaut
+        try {
+            const configs = await git.listConfig();
+            const currentDefaultBranch = configs.all['init.defaultbranch'];
+            const denyCurrentBranchConfig = configs.all['receive.denyCurrentBranch']?.toString().trim();
+            if (currentDefaultBranch !== gitConfig.mainBranch || forceUpdate) {
+                await git.addConfig('init.defaultBranch', gitConfig.mainBranch);
+                changes.push(`Set default branch to ${gitConfig.mainBranch}`);
+            }
+            if (denyCurrentBranchConfig !== 'updateInstead' && remoteUrl) {
+                await git.addConfig('receive.denyCurrentBranch', 'updateInstead');
+                changes.push('✓ Configured receive.denyCurrentBranch = updateInstead for local pushes');
+            }
+        }
+        catch (error) {
+            await git.addConfig('init.defaultBranch', gitConfig.mainBranch);
+            changes.push(`Set default branch to ${gitConfig.mainBranch}`);
+        }
+        // Configuration des Git Notes (avec ou sans remote)
+        try {
+            // Vérifier la configuration actuelle des notes
+            const notesConfig = await git.raw(['config', '--get', 'notes.rewriteRef']).catch(() => '');
+            if (!notesConfig.includes('refs/notes/commits') || forceUpdate) {
+                await git.addConfig('notes.rewriteRef', 'refs/notes/commits');
+                changes.push('✓ Configured Git Notes rewriteRef');
+            }
+        }
+        catch (error) {
+            console.warn('⚠️  Warning: Could not configure Git Notes:', error);
+        }
+        return {
+            configured: true,
+            changes
+        };
+    }
+    catch (error) {
+        throw new errors_1.GitOperationError(`Failed to ensure repository configuration: ${error}`, 'repo_config', { error });
+    }
+}
+/**
+ * Configure le remote origin et les paramètres Git Notes
+ * @param git Instance SimpleGit
+ * @param config Configuration du remote
+ */
+async function gitEnsureRemoteConfiguration(git, config) {
+    const { remoteUrl = (0, repo_tools_1.gitLoad)().remoteUrl, remoteName = 'origin', quiet } = config;
+    if (!remoteUrl) {
+        return;
+    }
+    try {
+        // Vérifier si le remote existe
+        const remotes = await git.getRemotes(true);
+        const existingRemote = remotes.find(r => r.name === remoteName);
+        // Ajouter fetch pour les notes (peut déjà exister)
+        try {
+            if (!existingRemote) {
+                console.log(`🔗 Adding remote ${remoteName} with URL ${remoteUrl}`);
+                await git.addRemote(remoteName, remoteUrl);
+                await git.addConfig(`remote.${remoteName}.fetch`, '+refs/notes/*:refs/notes/*');
+                console.log(`✅ Added Git Notes fetch configuration for ${remoteName}`);
+            }
+            else {
+                await git.addConfig(`remote.${remoteName}.push`, 'refs/notes/*:refs/notes/*');
+                console.log(`✅ Added Git Notes push configuration`);
+            }
+        }
+        catch (error) {
+            // Ignorer si la configuration existe déjà
+            console.log(`⚠️ Git Remote or Notes config may already exist`);
+        }
+    }
+    catch (error) {
+        if (!quiet)
+            throw new errors_1.GitOperationError(`Failed to configure remote: ${error}`, 'remote_config', { error });
+    }
+}
+async function gitInit(git, options = {}) {
+    try {
+        const gitConfig = (0, repo_tools_1.gitLoad)();
+        const { excludePatterns = [
+            'node_modules',
+            '.rag',
+            '.assets',
+            '.storage',
+            'dist',
+            '*.log',
+            '*.exe',
+            '*.dll',
+            '*.so',
+            '*.dylib',
+            '*.a',
+            '*.o',
+            '*.obj',
+            '*.lib',
+            '.env',
+            '.DS_Store',
+        ], remoteUrl = gitConfig?.remoteUrl, remoteName = 'origin' } = options;
+        const isRepo = await git.checkIsRepo();
+        if (isRepo) {
+            // Vérifier la configuration du remote même si le repo existe
+            await gitEnsureRemoteConfiguration(git, { remoteUrl, remoteName });
+            const existingBranches = await git.branchLocal();
+            const hasMainBranch = existingBranches.all.includes(gitConfig.mainBranch);
+            const hasDraftBranch = existingBranches.all.includes(gitConfig.draftBranch);
+            //
+            // missing configuration check
+            if (hasMainBranch && hasDraftBranch) {
+                if (gitConfig.verbose)
+                    console.log(`Repository already initialized with correct configuration at ${gitConfig.repoPath}`);
+                return;
+            }
+            if (gitConfig.verbose)
+                console.log(`🌶️ Repository already initialized with correct configuration at ${gitConfig.repoPath}`);
+            if (gitConfig.verbose)
+                console.log(`🌶️ Existing branches: ${existingBranches.all}`);
+            // Si le dépôt existe mais n'est pas correctement configuré
+            throw new errors_1.GitConfigurationError('Repository exists but is not properly configured. Please check branch names and configuration.', 'repo_config');
+        }
+        console.log(`🌳 Initializing repository at ${gitConfig.repoPath}`);
+        // Créer le répertoire temporaire
+        await fs.mkdir(gitConfig.repoPath, { recursive: true });
+        // Create upload directory (absolute path)
+        await fs.mkdir(gitConfig.uploadPath, { recursive: true });
+        console.log(`✅ Created upload directory: ${gitConfig.uploadPath}`);
+        // Initialiser le repository Git
+        await git.init();
+        // Configuration Git de base
+        await git.addConfig('init.defaultBranch', gitConfig.mainBranch);
+        // Configurer le remote origin et Git Notes si spécifié
+        await gitEnsureRemoteConfiguration(git, { remoteUrl, remoteName, quiet: true });
+        // Configuration des Git Notes (avec ou sans remote)
+        try {
+            await git.addConfig('notes.rewriteRef', 'refs/notes/commits');
+            console.log('✓ Configured Git Notes rewriteRef');
+        }
+        catch (error) {
+            console.warn('⚠️  Warning: Could not configure Git Notes:', error);
+        }
+        // Créer .gitignore si des patterns sont spécifiés
+        if (excludePatterns.length > 0) {
+            const gitignoreContent = excludePatterns.join('\n') + '\n';
+            await fs.writeFile((0, path_1.join)(gitConfig.repoPath, '.gitignore'), gitignoreContent, 'utf8');
+            await git.add('.gitignore');
+            await git.commit('chore: Add .gitignore', ['.gitignore']);
+        }
+        // Créer la branche main directement
+        await git.checkout(['-b', gitConfig.mainBranch]);
+        // Créer la branche draft à partir de main
+        await git.checkoutBranch(gitConfig.draftBranch, gitConfig.mainBranch);
+        console.log(`🌳 Repository initialized successfully at ${gitConfig.repoPath}`);
+    }
+    catch (error) {
+        throw new errors_1.GitOperationError(`Failed to init repository: ${error}`, 'repo_create', { error });
+    }
+}
+/**
+ * Fonction helper pour initialiser ou configurer un repository avec la configuration Git standard
+ * Cette fonction combine gitInit et gitEnsureRepositoryConfiguration pour une utilisation simple
+ * @param git Instance SimpleGit
+ * @param options Options de configuration
+ */
+async function gitSetupRepository(git, options = {}) {
+    const { remoteUrl, // Pas de valeur par défaut - peut être undefined pour un repository local
+    remoteName = 'origin', enableGitNotes = true, excludePatterns = [], forceReconfig = false } = options;
+    let initialized = false;
+    let configured = false;
+    const changes = [];
+    try {
+        const isRepo = await git.checkIsRepo();
+        if (!isRepo) {
+            // Initialiser le repository
+            console.log('🚀 Initializing new Git repository with standard configuration...');
+            await gitInit(git, {
+                excludePatterns,
+                remoteUrl,
+                remoteName,
+                enableGitNotes
+            });
+            initialized = true;
+            configured = true;
+            changes.push('Repository initialized with full configuration');
+        }
+        else {
+            console.log('📋 Repository exists, verifying configuration...');
+            // Configurer le repository existant
+            const result = await gitEnsureRepositoryConfiguration(git, {
+                remoteUrl,
+                remoteName,
+                forceUpdate: forceReconfig
+            });
+            configured = result.configured;
+            changes.push(...result.changes);
+        }
+        // Vérification finale
+        const configCheck = await gitCheckConfiguration(git);
+        console.log('📊 Configuration check results:', {
+            remoteOrigin: configCheck.remoteOrigin,
+            remoteOriginUrl: configCheck.remoteOriginUrl,
+            gitNotesRemoteFetch: configCheck.gitNotesRemoteFetch,
+            gitNotesRemotePush: configCheck.gitNotesRemotePush,
+            defaultBranch: configCheck.defaultBranch,
+            isValid: configCheck.isValid
+        });
+        return {
+            initialized,
+            configured,
+            changes
+        };
+    }
+    catch (error) {
+        throw new errors_1.GitOperationError(`Failed to setup repository: ${error}`, 'repo_setup', { error });
+    }
+}
+/**
+ * Fonction helper pour vérifier et afficher la configuration Git d'un repository
+ * @param git Instance SimpleGit
+ * @returns Configuration détaillée
+ */
+async function gitShowConfiguration(git) {
+    try {
+        const config = await gitCheckConfiguration(git);
+        console.log('\n🔍 === Git Repository Configuration Report ===');
+        console.log(`Repository Path: ${config.repoPath ? '✅' : '❌'}`);
+        console.log(`Draft Branch: ${config.draftBranch ? '✅' : '❌'}`);
+        console.log(`Main Branch: ${config.mainBranch ? '✅' : '❌'}`);
+        console.log(`Validation Prefix: ${config.validationPrefix ? '✅' : '❌'}`);
+        console.log(`Git Instance: ${config.instance ? '✅' : '❌'}`);
+        console.log(`Git Notes Config: ${config.gitNotes ? '✅' : '❌'}`);
+        if (config.remoteOrigin !== undefined) {
+            console.log(`\n🔗 Remote Configuration:`);
+            console.log(`Origin Remote: ${config.remoteOrigin ? '✅' : '❌'}`);
+            console.log(`Remote URL: ${config.remoteOriginUrl}`);
+            console.log(`Git Notes Fetch: ${config.gitNotesRemoteFetch ? '✅' : '❌'}`);
+            console.log(`Git Notes Push: ${config.gitNotesRemotePush ? '✅' : '❌'}`);
+            console.log(`Default Branch: ${config.defaultBranch ? '✅' : '❌'} (${config.defaultBranchValue})`);
+        }
+        console.log(`\n🎯 Overall Status: ${config.isValid ? '✅ VALID' : '❌ NEEDS CONFIGURATION'}`);
+        console.log('===============================================\n');
+        return config;
+    }
+    catch (error) {
+        throw new errors_1.GitOperationError(`Failed to show configuration: ${error}`, 'config_check', { error });
+    }
+}
+/**
+ * Vérifie la validité de la configuration Git (utilitaire)
+ * @param git Instance Git
+ * @returns Promise<boolean> True si la configuration est valide
+ */
+async function gitCheckConfiguration(git) {
+    const gitConfig = (0, repo_tools_1.gitLoad)();
+    const check = {
+        repoPath: (0, fs_1.existsSync)(gitConfig.repoPath),
+        uploadPath: (0, fs_1.existsSync)(gitConfig.uploadPath),
+        draftBranch: gitConfig.draftBranch.length > 0,
+        mainBranch: gitConfig.mainBranch.length > 0,
+        validationPrefix: gitConfig.validationPrefix.length > 0,
+        releasePrefix: gitConfig.releasePrefix.length > 0,
+        validationToken: gitConfig.validationToken.length > 0,
+        instance: gitConfig.instance && !!gitConfig.instance.add,
+        concurrency: gitConfig.concurrency &&
+            typeof gitConfig.concurrency.maxRetries === 'number' &&
+            typeof gitConfig.concurrency.retryDelayMs === 'number' &&
+            typeof gitConfig.concurrency.timeoutMs === 'number',
+        gitNotes: gitConfig.gitNotes &&
+            typeof gitConfig.gitNotes.namespace === 'string' &&
+            gitConfig.gitNotes.namespace.length > 0 &&
+            typeof gitConfig.gitNotes.enabled === 'boolean',
+    };
+    // Vérifications avancées si une instance Git est fournie
+    if (git) {
+        try {
+            check.remoteOrigin = false;
+            check.defaultBranch = false;
+            check.gitNotesRemoteFetch = false;
+            check.gitNotesRemotePush = false;
+            const isRepo = await git.checkIsRepo();
+            if (isRepo) {
+                // Vérifier la configuration du remote origin
+                const remotes = await git.getRemotes(true);
+                const originRemote = remotes.find(r => r.name === 'origin');
+                check.remoteOrigin = !!originRemote;
+                check.remoteOriginUrl = originRemote?.refs?.fetch || 'not configured';
+                // Vérifier la branche par défaut
+                try {
+                    const configs = await git.listConfig();
+                    const defaultBranch = configs.all['init.defaultbranch'];
+                    check.defaultBranch = defaultBranch === gitConfig.mainBranch;
+                    check.defaultBranchValue = defaultBranch || 'not set';
+                }
+                catch (error) {
+                    check.defaultBranchValue = 'error reading config';
+                }
+            }
+            else {
+                check.remoteOriginUrl = 'repository not initialized';
+                check.defaultBranchValue = 'repository not initialized';
+            }
+        }
+        catch (error) {
+            check.remoteOriginUrl = `error: ${error}`;
+            check.defaultBranchValue = `error: ${error}`;
+        }
+    }
+    // Calculate isValid based on core properties only (exclude remote-related checks)
+    const coreProperties = ['repoPath', 'uploadPath', 'draftBranch', 'mainBranch', 'validationPrefix', 'releasePrefix', 'validationToken', 'instance', 'concurrency', 'gitNotes', 'defaultBranch'];
+    check.isValid = coreProperties.every((key) => check[key] === true);
+    return check;
+}
+/**
+ * Crée un fichier dans la branche draft (opération bas niveau)
+ * @param git Instance Git
+ * @param filePath Chemin du fichier
+ * @param PR Nom de la branche de Pull Request
+ * @param content Contenu du fichier
+ * @param user Utilisateur qui effectue l'opération
+ * @param config Configuration Git (optionnel, utilise la config globale)
+ * @throws GitOperationError si la création échoue
+ */
+async function gitCreateOrEditFile(git, filePath, PR, content, user, config) {
+    //
+    // lock checkout is global
+    await (0, repo_tools_1.lock)(`checkout`);
+    let currentBranch;
+    try {
+        const gitConf = (0, repo_tools_1.gitLoad)(config);
+        //
+        // secure main and draft branches (on production)
+        if (!gitConf?.canForce && PR == gitConf.mainBranch) {
+            throw new errors_1.GitOperationError('Cannot create files in main branch', 'gitCreateOrEditFile', { filePath, PR });
+        }
+        if (!gitConf?.canForce && PR == gitConf.draftBranch) {
+            throw new errors_1.GitOperationError('Cannot create files in draft branch', 'gitCreateOrEditFile', { filePath, PR });
+        }
+        currentBranch = await git.revparse(['--abbrev-ref', 'HEAD']);
+        if (currentBranch !== PR) {
+            await git.checkout(PR);
+        }
+        const oldHead = (await git.revparse(['HEAD'])).trim();
+        //
+        // without note the branche is not a valid PR branch
+        const oldNote = await (0, repo_tools_1.gitReadNote)(git, PR, gitConf.gitNotes.namespace, 10);
+        const commit = await _writeFileAndCommit(git, filePath, content, user, gitConf, `commit: ${filePath}`);
+        if (!oldNote) {
+            return {
+                hash: commit.commit,
+                date: new Date(),
+                message: `commit: ${filePath}`,
+                author: {
+                    name: user.name,
+                    email: user.email
+                },
+                branch: PR
+            };
+        }
+        // Determine the current head after the commit attempt.
+        const newHead = (await git.revparse(['HEAD'])).trim();
+        const newFiles = await (0, repo_tools_1.gitGetDiffFiles)(git, PR, oldNote.mergeBase);
+        const updatedNote = {
+            ...oldNote,
+            files: newFiles,
+        };
+        // Write the note to the current HEAD of the PR branch.
+        // If no commit was made, this overwrites the note on oldHead.
+        // If a new commit was made, this writes the note on newHead.
+        await (0, repo_tools_1.gitWriteNote)(git, PR, updatedNote, gitConf.gitNotes.namespace);
+        // If a new commit was created, the old note on oldHead is now obsolete and should be removed.
+        if (newHead !== oldHead) {
+            await (0, repo_tools_1.gitDeleteNote)(git, oldHead, gitConf.gitNotes.namespace);
+        }
+        const log = await git.log(['-n', '1', PR, '--', filePath]);
+        //
+        // SHOULD NEVER HAPPEN
+        if (!log.latest) {
+            throw new errors_1.GitOperationError(`Failed to get commit history for ${filePath}`, 'gitCreateOrEditFile', { filePath });
+        }
+        return {
+            hash: log.latest.hash,
+            date: new Date(log.latest.date),
+            message: log.latest.message,
+            author: {
+                name: log.latest.author_name,
+                email: log.latest.author_email
+            },
+            branch: PR
+        };
+    }
+    catch (error) {
+        throw new errors_1.GitOperationError(`Failed to create or edit file "${filePath}": ${error}`, 'gitCreateOrEditFile', { filePath, error });
+    }
+    finally {
+        if (currentBranch && currentBranch !== PR) {
+            await git.checkout(currentBranch);
+        }
+        (0, repo_tools_1.unlock)(`checkout`);
+    }
+}
+/**
+ * Modifie un fichier dans la branche draft (opération bas niveau)
+ * @param git Instance Git
+ * @param filePath Chemin du fichier
+ * @param PR Nom de la branche de Pull Request
+ * @param content Contenu du fichier
+ * @param user Utilisateur qui effectue l'opération
+ * @param config Configuration Git (optionnel, utilise la config globale)
+ * @throws GitOperationError si la modification échoue
+ */
+async function gitEditFile(git, filePath, PR, content, user, config) {
+    const exists = await (0, repo_tools_1.gitFileExistsInBranch)(git, filePath, PR);
+    if (!exists) {
+        throw new errors_1.FileNotFoundError(filePath, PR);
+    }
+    return await gitCreateOrEditFile(git, filePath, PR, content, user, config);
+}
+async function gitRenameFile_git(git, oldFileName, newFileName, branch, user, config) {
+    // Si les noms sont identiques, pas besoin de renommer
+    if (oldFileName === newFileName) {
+        return {
+            hash: '',
+            date: new Date(),
+            message: 'No rename needed - files are identical',
+            author: { name: user.name, email: user.email },
+            branch: branch
+        };
+    }
+    const gitConf = (0, repo_tools_1.gitLoad)(config);
+    const currentBranch = await git.revparse(['--abbrev-ref', 'HEAD']);
+    try {
+        await (0, repo_tools_1.lock)(`checkout`);
+        // Vérifier que l'ancien fichier existe
+        const oldFileExists = await (0, repo_tools_1.gitFileExistsInBranch)(git, oldFileName, branch);
+        if (!oldFileExists) {
+            throw new errors_1.FileNotFoundError(oldFileName, branch);
+        }
+        // Vérifier que le nouveau fichier n'existe pas déjà
+        const newFileExists = await (0, repo_tools_1.gitFileExistsInBranch)(git, newFileName, branch);
+        if (newFileExists) {
+            throw new Error(`Le fichier de destination "${newFileName}" existe déjà dans la branche "${branch}"`);
+        }
+        await git.checkout(branch);
+        // Rename file with git mv (atomique dans Git)
+        await git.raw(['mv', oldFileName, newFileName]);
+        // Commit - git mv automatically stages changes
+        const commit = await git.commit(`rename: ${oldFileName} → ${newFileName}`, {
+            '--author': `${user.name} <${user.email}>`
+        });
+        return {
+            hash: commit.commit,
+            date: new Date(),
+            message: `rename: ${oldFileName} → ${newFileName}`,
+            author: {
+                name: user.name,
+                email: user.email
+            },
+            branch: branch
+        };
+    }
+    catch (error) {
+        // En cas d'erreur, essayer de restaurer l'état initial
+        try {
+            await git.reset(['--hard']);
+        }
+        catch (resetError) {
+            console.warn('Could not reset after failed rename:', resetError);
+        }
+        throw error;
+    }
+    finally {
+        if (currentBranch) {
+            await git.checkout(currentBranch);
+        }
+        (0, repo_tools_1.unlock)(`checkout`);
+    }
+}
+async function gitRenameFile_fs(git, oldFileName, newFileName, branch, user, config) {
+    // Si les noms sont identiques, pas besoin de renommer
+    if (oldFileName === newFileName) {
+        return {
+            hash: '',
+            date: new Date(),
+            message: 'No rename needed - files are identical',
+            author: { name: user.name, email: user.email },
+            branch: branch
+        };
+    }
+    const gitConf = (0, repo_tools_1.gitLoad)(config);
+    try {
+        await (0, repo_tools_1.lock)(`checkout`);
+        const fullNewPath = (0, path_1.join)(gitConf.uploadPath, newFileName);
+        const fullOldPath = (0, path_1.join)(gitConf.uploadPath, oldFileName);
+        // Vérifier que l'ancien fichier existe
+        const oldFileExists = (0, fs_1.existsSync)(fullOldPath);
+        if (!oldFileExists) {
+            throw new errors_1.FileNotFoundError(oldFileName, branch);
+        }
+        // Vérifier que le nouveau fichier n'existe pas déjà
+        const newFileExists = (0, fs_1.existsSync)(fullNewPath);
+        if (newFileExists) {
+            throw new Error(`Le fichier de destination "${newFileName}" existe déjà sur le système de fichiers`);
+        }
+        // Renommage atomique filesystem
+        // Utiliser copyFile + unlink pour plus de sécurité que rename() sur certains systèmes
+        try {
+            await fs.copyFile(fullOldPath, fullNewPath);
+            await fs.unlink(fullOldPath);
+        }
+        catch (copyError) {
+            // En cas d'erreur, nettoyer le nouveau fichier s'il a été créé
+            if ((0, fs_1.existsSync)(fullNewPath)) {
+                try {
+                    await fs.unlink(fullNewPath);
+                }
+                catch (cleanupError) {
+                    console.warn('Could not cleanup destination file after failed rename:', cleanupError);
+                }
+            }
+            throw copyError;
+        }
+        return {
+            hash: '',
+            date: new Date(),
+            message: `filesystem rename: ${oldFileName} → ${newFileName}`,
+            author: {
+                name: user.name,
+                email: user.email
+            },
+            branch: branch
+        };
+    }
+    catch (error) {
+        throw error;
+    }
+    finally {
+        (0, repo_tools_1.unlock)(`checkout`);
+    }
+}
+/**
+ * Renomme un fichier de manière atomique (Git ou filesystem selon le contexte)
+ * @param git Instance SimpleGit
+ * @param oldFileName Ancien nom du fichier
+ * @param newFileName Nouveau nom du fichier
+ * @param branch Branche où effectuer le renommage
+ * @param user Utilisateur effectuant l'opération
+ * @param config Configuration Git optionnelle
+ * @returns Historique du commit de renommage
+ */
+async function gitRenameFile(git, oldFileName, newFileName, branch, user, config) {
+    // Si les noms sont identiques, pas besoin de renommer
+    if (oldFileName === newFileName) {
+        return {
+            hash: '',
+            date: new Date(),
+            message: 'No rename needed - files are identical',
+            author: { name: user.name, email: user.email },
+            branch: branch
+        };
+    }
+    // load config
+    const gitConf = (0, repo_tools_1.gitLoad)(config);
+    // Pour les fichiers dans Git, utiliser Git uniquement (pas de fallback filesystem)
+    try {
+        //
+        //FIXME: add a check about the branch (file can be NEW and on branch)
+        const fullOldPath = (0, path_1.join)(gitConf.uploadPath, oldFileName);
+        if ((0, fs_1.existsSync)(fullOldPath)) {
+            return await gitRenameFile_fs(git, oldFileName, newFileName, branch, user, config);
+        }
+        else {
+            return await gitRenameFile_git(git, oldFileName, newFileName, branch, user, config);
+        }
+    }
+    catch (error) {
+        // Pour les vraies branches Git, ne pas faire de fallback filesystem
+        // Seules les branches NEW utilisent le filesystem
+        throw error;
+    }
+}
+/**
+ * Supprime un fichier d'une branche Git (opération bas niveau)
+ * @param git Instance Git
+ * @param filePath Chemin du fichier à supprimer
+ * @param branch Nom de la branche où supprimer le fichier
+ * @param user Utilisateur qui effectue l'opération
+ * @param config Configuration Git (optionnel, utilise la config globale)
+ * @throws GitOperationError si la suppression échoue
+ */
+async function gitDeleteFile(git, filePath, branch, user, config) {
+    await (0, repo_tools_1.lock)(`checkout`);
+    let currentBranch;
+    try {
+        const gitConf = (0, repo_tools_1.gitLoad)(config);
+        // Sécurité : interdire la suppression dans les branches de production
+        if (!gitConf?.canForce && branch === gitConf.mainBranch) {
+            throw new errors_1.GitOperationError('Cannot delete files in main branch', 'gitDeleteFile', { filePath, branch });
+        }
+        if (!gitConf?.canForce && branch === gitConf.draftBranch) {
+            throw new errors_1.GitOperationError('Cannot delete files in draft branch', 'gitDeleteFile', { filePath, branch });
+        }
+        // Vérifier que le fichier existe avant de le supprimer
+        const exists = await (0, repo_tools_1.gitFileExistsInBranch)(git, filePath, branch);
+        if (!exists) {
+            throw new errors_1.FileNotFoundError(filePath, branch);
+        }
+        currentBranch = await git.revparse(['--abbrev-ref', 'HEAD']);
+        if (currentBranch !== branch) {
+            await git.checkout(branch);
+        }
+        const oldHead = (await git.revparse(['HEAD'])).trim();
+        // Lire l'ancienne note pour la mettre à jour
+        const oldNote = await (0, repo_tools_1.gitReadNote)(git, branch, gitConf.gitNotes.namespace, 10);
+        // Supprimer le fichier avec git rm
+        await git.raw(['rm', filePath]);
+        // Commit la suppression
+        const commit = await git.commit(`delete: ${filePath}`, {
+            '--author': `${user.name} <${user.email}>`
+        });
+        // Mettre à jour la note si elle existe (pour les branches PR)
+        if (oldNote) {
+            const newHead = (await git.revparse(['HEAD'])).trim();
+            const newFiles = await (0, repo_tools_1.gitGetDiffFiles)(git, branch, oldNote.mergeBase);
+            const updatedNote = {
+                ...oldNote,
+                files: newFiles,
+            };
+            // Écrire la note sur le nouveau HEAD
+            await (0, repo_tools_1.gitWriteNote)(git, branch, updatedNote, gitConf.gitNotes.namespace);
+            // Supprimer l'ancienne note si un nouveau commit a été créé
+            if (newHead !== oldHead) {
+                await (0, repo_tools_1.gitDeleteNote)(git, oldHead, gitConf.gitNotes.namespace);
+            }
+        }
+        return {
+            hash: commit.commit,
+            date: new Date(),
+            message: `delete: ${filePath}`,
+            author: {
+                name: user.name,
+                email: user.email
+            },
+            branch: branch
+        };
+    }
+    catch (error) {
+        throw new errors_1.GitOperationError(`Failed to delete file "${filePath}" from branch "${branch}": ${error}`, 'gitDeleteFile', { filePath, branch, error });
+    }
+    finally {
+        if (currentBranch && currentBranch !== branch) {
+            await git.checkout(currentBranch);
+        }
+        (0, repo_tools_1.unlock)(`checkout`);
+    }
+}
+/**
+ * PRIVATE TOOLS
+ */
+const _writeFileAndCommit = async (git, filePath, content, user, config, commitMsg) => {
+    const gitConf = config;
+    if (!gitConf || !gitConf.repoPath) {
+        throw new errors_1.GitOperationError('_writeFileAndCommit requires a config with a valid repoPath.', 'internal_error');
+    }
+    // Créer les répertoires parents si nécessaire
+    const fullPath = (0, path_1.join)(gitConf.repoPath, filePath);
+    const dir = (0, path_1.dirname)(fullPath);
+    await fs.mkdir(dir, { recursive: true });
+    // Écrire le fichier
+    await fs.writeFile(fullPath, content, { encoding: 'utf8', flag: 'w' });
+    await git.add(filePath);
+    const commit = await git.commit(commitMsg || `commit`, [filePath], {
+        '--author': `${user.name} <${user.email}>`
+    });
+    return commit;
+};
+/**
+ * Diagnostique l'état de santé d'une branche Git et détecte les problèmes bloquants.
+ *
+ * **Problèmes bloquants détectés :**
+ * - ❌ **Branche inexistante** : La branche spécifiée n'existe pas dans le dépôt
+ * - ❌ **Branche inaccessible** : Impossible de faire un checkout vers la branche
+ * - ❌ **Merge en cours** : Opération de merge interrompue (fichiers .git/MERGE_HEAD présents)
+ * - ❌ **Fichiers en conflit** : Conflits de merge non résolus (status.conflicted)
+ * - ❌ **Index Git corrompu** : Index illisible ou corrompu (git status échoue)
+ * - ⚠️  **Fichiers modifiés** : Changements non commités dans le working directory
+ * - ⚠️  **Fichiers stagés** : Changements en attente de commit dans l'index
+ *
+ * **Méthode de diagnostic :**
+ * 1. Vérification de l'existence de la branche (git branch --list)
+ * 2. Test d'accessibilité (git checkout)
+ * 3. Analyse de l'état (git status)
+ * 4. Détection des merges en cours (fichiers .git/MERGE_*)
+ *
+ * @param git Instance SimpleGit configurée
+ * @param branch Nom de la branche à diagnostiquer (optionnel, utilise la branche courante si non spécifié)
+ * @returns Promise<GitHealthStatus> Diagnostic complet avec liste des problèmes et recommandations de réparation
+ */
+async function gitGetBranchHealth(git, branch) {
+    const gitConfig = (0, repo_tools_1.gitLoad)();
+    let currentBranch = branch;
+    // Si pas de branche spécifiée, utiliser la branche courante
+    if (!currentBranch) {
+        try {
+            currentBranch = await git.revparse(['--abbrev-ref', 'HEAD']);
+        }
+        catch (error) {
+            return createUnhealthyStatus('unknown', false, false, false, false, 0, 0, 0, 0, false, ['Impossible de déterminer la branche courante'], ['Vérifier l\'état du dépôt Git']);
+        }
+    }
+    const health = {
+        branch: currentBranch,
+        exists: false,
+        accessible: false,
+        clean: false,
+        mergeInProgress: false,
+        conflictedFiles: 0,
+        modifiedFiles: 0,
+        untrackedFiles: 0,
+        stagedFiles: 0,
+        indexReadable: false,
+        healthy: false,
+        issues: [],
+        recommendations: []
+    };
+    try {
+        // 1. Vérifier si la branche existe
+        const branches = await git.branchLocal();
+        health.exists = branches.all.includes(currentBranch);
+        if (!health.exists) {
+            health.issues.push(`La branche '${currentBranch}' n'existe pas`);
+            health.recommendations.push(`Créer la branche ou vérifier le nom`);
+            return health;
+        }
+        // 2. Tenter un checkout pour vérifier l'accessibilité
+        const originalBranch = await git.revparse(['--abbrev-ref', 'HEAD']).catch(() => null);
+        try {
+            if (originalBranch !== currentBranch) {
+                await git.checkout(currentBranch);
+            }
+            health.accessible = true;
+            // 3. Vérifier l'état avec git status
+            try {
+                const status = await git.status();
+                health.indexReadable = true;
+                health.clean = status.isClean();
+                health.conflictedFiles = status.conflicted.length;
+                health.modifiedFiles = status.modified.length;
+                health.untrackedFiles = status.not_added.length;
+                health.stagedFiles = status.staged.length;
+                // 4. Vérifier si un merge est en cours
+                health.mergeInProgress = await checkMergeInProgress(gitConfig.repoPath);
+            }
+            catch (statusError) {
+                health.indexReadable = false;
+                health.issues.push('Index Git illisible ou corrompu');
+                health.recommendations.push('Exécuter git reset --hard HEAD');
+            }
+            // Restaurer la branche originale si nécessaire
+            if (originalBranch && originalBranch !== currentBranch) {
+                await git.checkout(originalBranch).catch(() => {
+                    // Si on ne peut pas revenir, ce n'est pas critique pour le diagnostic
+                });
+            }
+        }
+        catch (checkoutError) {
+            health.accessible = false;
+            health.issues.push(`Impossible d'accéder à la branche '${currentBranch}'`);
+            health.recommendations.push('Exécuter git checkout -f ' + currentBranch);
+        }
+    }
+    catch (error) {
+        health.issues.push(`Erreur lors du diagnostic : ${error.message}`);
+        health.recommendations.push('Vérifier l\'état du dépôt Git');
+    }
+    // 5. Analyser les problèmes et recommandations
+    if (health.mergeInProgress) {
+        health.issues.push('Merge en cours');
+        health.recommendations.push('Exécuter git merge --abort');
+    }
+    if (health.conflictedFiles > 0) {
+        health.issues.push(`${health.conflictedFiles} fichier(s) en conflit`);
+        health.recommendations.push('Résoudre les conflits ou exécuter git reset --hard HEAD');
+    }
+    if (health.modifiedFiles > 0 || health.stagedFiles > 0) {
+        health.issues.push(`${health.modifiedFiles} fichier(s) modifié(s), ${health.stagedFiles} fichier(s) stagé(s)`);
+        health.recommendations.push('Committer les changements ou exécuter git reset --hard HEAD');
+    }
+    if (!health.indexReadable) {
+        health.issues.push('Index Git corrompu');
+        health.recommendations.push('Exécuter git reset --hard HEAD');
+    }
+    // 6. Déterminer l'état de santé global
+    health.healthy = health.exists &&
+        health.accessible &&
+        health.indexReadable &&
+        !health.mergeInProgress &&
+        health.conflictedFiles === 0 &&
+        (health.clean || (health.modifiedFiles === 0 && health.stagedFiles === 0));
+    return health;
+}
+/**
+ * Fonction helper pour créer un statut unhealthy
+ */
+function createUnhealthyStatus(branch, exists, accessible, clean, mergeInProgress, conflictedFiles, modifiedFiles, untrackedFiles, stagedFiles, indexReadable, issues, recommendations) {
+    return {
+        branch,
+        exists,
+        accessible,
+        clean,
+        mergeInProgress,
+        conflictedFiles,
+        modifiedFiles,
+        untrackedFiles,
+        stagedFiles,
+        indexReadable,
+        healthy: false,
+        issues,
+        recommendations
+    };
+}
+/**
+ * Vérifie si un merge est en cours en regardant les fichiers Git
+ */
+async function checkMergeInProgress(repoPath) {
+    const { existsSync } = await Promise.resolve().then(() => __importStar(require('fs')));
+    const { join } = await Promise.resolve().then(() => __importStar(require('path')));
+    const gitDir = join(repoPath, '.git');
+    const mergeFiles = [
+        'MERGE_HEAD',
+        'MERGE_MODE',
+        'MERGE_MSG',
+        'CHERRY_PICK_HEAD',
+        'REVERT_HEAD'
+    ];
+    return mergeFiles.some(file => existsSync(join(gitDir, file)));
+}