agentic-api 1.0.5 → 2.0.26

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

@@ -0,0 +1,589 @@
+"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.gitSyncPR = gitSyncPR;
+exports.gitIsPRClosed = gitIsPRClosed;
+exports.gitIsPRClosedRobust = gitIsPRClosedRobust;
+exports.gitGetPRMetadata = gitGetPRMetadata;
+exports.gitGetAllPR = gitGetAllPR;
+exports.gitGetClosedPRs = gitGetClosedPRs;
+exports.gitLoadPR = gitLoadPR;
+exports.gitPRUpdateComments = gitPRUpdateComments;
+exports.gitClosePR = gitClosePR;
+exports.gitClosePRRobust = gitClosePRRobust;
+exports.gitGetNextPRNumber = gitGetNextPRNumber;
+exports.gitNewValidationRequest = gitNewValidationRequest;
+exports.gitNewPR = gitNewPR;
+const errors_1 = require("../errors");
+const path_1 = require("path");
+const fs = __importStar(require("fs/promises"));
+const repo_tools_1 = require("./repo.tools");
+/**
+ * Synchronise une branche PR avec son mergeBase pour corriger les références orphelines
+ *
+ * FIXME: Cette fonction a un problème de gestion des métadonnées manquantes.
+ *
+ * PROBLÈME IDENTIFIÉ:
+ * - Les branches de validation (rule-validation-*) DOIVENT avoir des métadonnées PR
+ * - Actuellement, si les métadonnées sont manquantes, la fonction fait un return silencieux
+ * - Ceci masque un vrai problème : pourquoi une branche de validation n'a pas de métadonnées ?
+ *
+ * CAUSES POSSIBLES:
+ * - Problème de namespace Git Notes (création vs lecture dans des namespaces différents)
+ * - Race condition entre création et lecture des Git Notes
+ * - Configuration E2E différente entre helper.newPR() et gitSyncPR()
+ * - Corruption des Git Notes lors de la simulation du "reset" dans le test
+ *
+ * SOLUTION RECOMMANDÉE:
+ * - Ajouter un diagnostic approfondi pour identifier pourquoi les métadonnées sont manquantes
+ * - Distinguer le traitement : strict pour branches de validation, tolérant pour autres branches
+ * - Corriger la cause racine au lieu de masquer le symptôme
+ *
+ * IMPACT MÉTIER:
+ * - Une branche de validation sans métadonnées indique un problème d'intégrité des données
+ * - Le comportement actuel (return silencieux) peut masquer des corruptions de données
+ * - Les utilisateurs pourraient perdre des informations de PR importantes
+ *
+ * @param git Instance Git
+ * @param branch Nom de la branche PR à synchroniser
+ * @param user Utilisateur qui effectue la synchronisation
+ * @returns Promise<void>
+ */
+async function gitSyncPR(git, branch, user) {
+    const gitConfig = (0, repo_tools_1.gitLoad)();
+    await (0, repo_tools_1.lock)('checkout');
+    let currentBranch;
+    try {
+        currentBranch = await git.revparse(['--abbrev-ref', 'HEAD']);
+        // Vérifier que la branche PR existe
+        const allBranches = await (0, repo_tools_1.gitGetAllBranches)(git);
+        if (!allBranches.includes(branch)) {
+            throw new errors_1.BranchNotFoundError(branch);
+        }
+        // Charger les métadonnées de la PR
+        const pr = await gitLoadPR(git, branch);
+        if (!pr || !pr.metadata) {
+            throw new errors_1.GitOperationError(`PR metadata not found for branch ${branch}`, 'pr_sync', { branch });
+        }
+        if (pr.metadata.status === 'closed') {
+            return;
+        }
+        // Vérifier que le mergeBase existe et est accessible
+        const mergeBase = pr.metadata.mergeBase;
+        if (!mergeBase) {
+            throw new errors_1.GitOperationError(`No merge base found for PR ${branch}`, 'pr_sync', { branch });
+        }
+        try {
+            // Vérifier que le mergeBase est un commit valide
+            await git.raw(['rev-parse', '--verify', `${mergeBase}^{commit}`]);
+        }
+        catch (error) {
+            throw new errors_1.GitOperationError(`Merge base ${mergeBase} is not a valid commit for PR ${branch}`, 'pr_sync', { branch, mergeBase, error });
+        }
+        // Basculer vers la branche PR
+        await git.checkout(branch);
+        // Effectuer le merge avec stratégie "recursive" et option "theirs" pour gérer les conflits
+        try {
+            // const merge =await git.env({
+            //   GIT_COMMITTER_NAME: user.name,
+            //   GIT_COMMITTER_EMAIL: user.email
+            // }).raw([
+            //
+            // ours   = (branche PR avec travail éditeur) → PRÉSERVÉ le travail éditeur
+            // theirs = (mergeBase avec modifications concurrentes) → IGNORÉ en cas de conflit
+            const merge = await git.raw([
+                'merge',
+                mergeBase,
+                '--no-ff',
+                '--strategy', 'recursive',
+                '--strategy-option', 'ours',
+                '-m', `Sync: Merge ${mergeBase} into ${branch}`
+            ]);
+            //console.log('merge',merge);
+        }
+        catch (mergeError) {
+            console.log('mergeError', mergeError);
+            // FIXME: this is a fallback, we should not use it
+            // En cas d'échec du merge, tenter avec une stratégie plus agressive
+            try {
+                await git.raw(['merge', '--abort']).catch(() => { }); // Ignore si pas de merge en cours
+                await git.raw([
+                    'merge',
+                    mergeBase,
+                    '--no-ff',
+                    '--strategy', 'ours',
+                    '-m', `Sync: Force merge ${mergeBase} into ${branch} (conflicts resolved)`
+                ]);
+            }
+            catch (fallbackError) {
+                throw new errors_1.GitOperationError(`Failed to sync PR ${branch} with merge base ${mergeBase}: ${mergeError}`, 'pr_sync', { branch, mergeBase, mergeError, fallbackError });
+            }
+        }
+        // Préserver les fichiers originaux de la PR (ne pas recalculer après merge)
+        // Note: Après un merge réussi, gitGetDiffFiles retournera [] car il n'y a plus de différences
+        // Les fichiers de la PR sont une information historique qui doit être préservée
+        const updatedMetadata = {
+            ...pr.metadata,
+            files: pr.metadata.files, // Préserver les fichiers originaux
+            timestamp: new Date().toISOString(),
+            lastSync: new Date().toISOString(), // Ajouter timestamp de synchronisation
+        };
+        // Get the commit hash of the HEAD of the branch
+        const headCommitHash = (await git.revparse([branch])).trim();
+        await (0, repo_tools_1.gitWriteNote)(git, headCommitHash, updatedMetadata, gitConfig.gitNotes.namespace);
+    }
+    catch (error) {
+        if (error instanceof errors_1.GitOperationError || error instanceof errors_1.BranchNotFoundError) {
+            throw error;
+        }
+        throw new errors_1.GitOperationError(`Failed to sync PR ${branch}: ${error}`, 'pr_sync', { branch, error });
+    }
+    finally {
+        if (currentBranch) {
+            try {
+                await git.checkout(currentBranch);
+            }
+            catch (checkoutError) {
+                if (gitConfig.verbose) {
+                    console.error(`Failed to checkout back to ${currentBranch}: ${checkoutError}`);
+                }
+            }
+        }
+        (0, repo_tools_1.unlock)('checkout');
+    }
+}
+/**
+ * Vérifie si une branche PR est fermée en regardant le message du dernier commit
+ * @param git Instance Git
+ * @param branch Nom de la branche PR
+ * @param validationToken Token utilisé pour marquer la fermeture (optionnel, utilise la config par défaut)
+ * @returns true si le PR est fermé (dernier commit contient le token de validation)
+ * DEPRECATED: use gitIsPRClosedRobust instead
+ */
+async function gitIsPRClosed(git, branch) {
+    return gitIsPRClosedRobust(git, branch);
+}
+/**
+ * Vérifie si une branche PR est fermée en utilisant Git Notes (avec fallback)
+ * Version robuste qui remplace gitIsPRClosed
+ * @param git Instance Git
+ * @param branch Nom de la branche PR
+ * @param validationToken Token utilisé pour marquer la fermeture (optionnel, utilise la config par défaut)
+ * @param config Configuration Git (optionnel, utilise la config globale)
+ * @returns true si le PR est fermé
+ */
+async function gitIsPRClosedRobust(git, branch, config) {
+    const gitConfig = (0, repo_tools_1.gitLoad)(config);
+    try {
+        const note = await gitGetPRMetadata(git, branch, config);
+        // If the branch is not found, then METADATA is Null, it is closed
+        if (!note) {
+            return true;
+        }
+        return ['closed', 'merged'].includes(note.status);
+    }
+    catch (error) {
+        // If the branch is not found, or not compliant with METADATA, it is closed
+        return true;
+    }
+}
+/**
+ * Vérifie si une branche PR est fermée en utilisant Git Notes (avec fallback)
+ * Version robuste qui remplace gitIsPRClosed
+ * @param git Instance Git
+ * @param branch Nom de la branche PR
+ * @param validationToken Token utilisé pour marquer la fermeture (optionnel, utilise la config par défaut)
+ * @param config Configuration Git (optionnel, utilise la config globale)
+ * @returns true si le PR est fermé
+ */
+async function gitGetPRMetadata(git, branch, config) {
+    const gitConf = (0, repo_tools_1.gitLoad)(config);
+    try {
+        // D'abord essayer de chercher sur le commit HEAD de la branche
+        let metadata = await (0, repo_tools_1.gitReadNote)(git, branch, gitConf.gitNotes.namespace, 20);
+        // DEPRECATED: we now we always use the last 20 commits to find the metadata
+        // if (!metadata) {
+        //   metadata = await gitReadNote(git, branch, gitConf.gitNotes.namespace, 20);
+        // }
+        return metadata;
+    }
+    catch (error) {
+        // This typically happens if the branch doesn't exist, which is a valid case.
+        return null;
+    }
+}
+/**
+ * Récupère tous les pull requests (branches rule-validation-*) avec leur statut
+ * @param git Instance Gitno
+ * @param options Configuration pour filtrer les PRs (default: list open PRs)
+ * @returns Liste des PRs avec leur statut (au niveau de la branche)
+ */
+async function gitGetAllPR(git, options = {}) {
+    try {
+        const gitConfig = (0, repo_tools_1.gitLoad)();
+        const { closed: listOnlyClosed, validationPrefix = gitConfig.validationPrefix, } = options;
+        const allLocalBranchesRaw = await (0, repo_tools_1.gitGetAllBranches)(git);
+        const prCandidateBranches = allLocalBranchesRaw.filter((branch) => branch.startsWith(validationPrefix));
+        const prs = [];
+        for (const branch of prCandidateBranches) {
+            try {
+                const pr = await gitLoadPR(git, branch);
+                const isOpen = pr.metadata.status === 'open';
+                if (listOnlyClosed) {
+                    if (!isOpen) {
+                        prs.push(pr);
+                    }
+                }
+                else {
+                    if (isOpen) {
+                        prs.push(pr);
+                    }
+                }
+            }
+            catch (error) {
+                if (gitConfig.verbose)
+                    console.error(`[gitGetAllPR] Error loading PR ${branch}:`, error);
+                continue;
+            }
+        }
+        return prs;
+    }
+    catch (error) {
+        throw new errors_1.GitOperationError(`Failed to retrieve PRs: ${error}`, 'pr_listing', { options, originalError: error });
+    }
+}
+/**
+ * Finds closed PRs by scanning the history of the draft branch for merge commits with PR metadata.
+ * @param git SimpleGit instance
+ * @param gitConfig The git configuration
+ * @returns A list of PRInfo objects for closed PRs.
+ */
+async function gitGetClosedPRs(git, gitConfig) {
+    const log = await git.log({
+        from: gitConfig.draftBranch,
+        '--merges': null, // Only show merge commits
+    });
+    const prs = [];
+    for (const commit of log.all) {
+        const note = await (0, repo_tools_1.gitReadNote)(git, commit.hash, gitConfig.gitNotes.namespace, 1);
+        if (note && note.status === 'closed' && note.id) {
+            const pr = {
+                branch: `${gitConfig.validationPrefix}${note.id}`, // Reconstruct original branch name
+                files: note.files || [],
+                open: false,
+                lastCommit: commit.hash,
+                lastCommitMessage: commit.message,
+                lastModified: new Date(commit.date),
+                metadata: note,
+                toString() { return this.branch; }
+            };
+            prs.push(pr);
+        }
+    }
+    return prs;
+}
+async function gitLoadPR(git, branch) {
+    try {
+        // Load metadata from 
+        const metadata = await gitGetPRMetadata(git, branch);
+        if (!metadata) {
+            throw new errors_1.GitOperationError(`PR not found for branch ${branch}`, 'pr_load', { branch });
+        }
+        const files = metadata.files || await (0, repo_tools_1.gitGetDiffFiles)(git, branch, metadata?.mergeBase, '.md');
+        // Récupérer les infos du dernier commit de la branche
+        const log = await git.log({ from: branch, to: branch, maxCount: 1 });
+        const lastCommit = log.latest;
+        const pr = {
+            branch,
+            files,
+            open: metadata.status == 'open',
+            lastCommit: lastCommit?.hash,
+            lastCommitMessage: lastCommit?.message,
+            lastModified: lastCommit?.date ? new Date(lastCommit.date) : undefined,
+            metadata: metadata, // metadata should exist if we read a note
+            toString() { return this.branch; }
+        };
+        return pr;
+    }
+    catch (error) {
+        throw new errors_1.GitOperationError(`Failed to retrieve PR: ${error}`, 'pr_load');
+    }
+}
+async function gitPRUpdateComments(git, branch, details, config) {
+    const gitConf = (0, repo_tools_1.gitLoad)(config);
+    const metadata = await gitGetPRMetadata(git, branch, config);
+    if (!metadata) {
+        throw new errors_1.GitOperationError(`PR not found for branch ${branch}`, 'pr_load', { branch });
+    }
+    // FIXME: only the owner of the PR can update metadatas
+    metadata.comments = details.comments || metadata.comments;
+    metadata.readyForValidation = details.readyForValidation;
+    //
+    // update validator only if it is not already set
+    if (details.validator) {
+        metadata.validator = details.validator;
+    }
+    // Get the commit hash of the HEAD of the branch
+    const headCommitHash = (await git.revparse([branch])).trim();
+    await (0, repo_tools_1.gitWriteNote)(git, headCommitHash, metadata, gitConf.gitNotes.namespace);
+    return gitLoadPR(git, branch);
+}
+/**
+ * DEPRECATED: use gitClosePRRobust instead
+ * Ferme un PR en ajoutant un commit avec le token de validation
+ * @param git Instance Git
+ * @param branch Branche PR à fermer
+ * @param author Utilisateur qui ferme le PR
+ * @param message Message optionnel à ajouter avant le token de validation
+ * @param validationToken Token utilisé pour marquer la fermeture (optionnel, utilise la config par défaut)
+ * @returns Hash du commit de fermeture
+ * DEPRECATED: use gitClosePRRobust instead
+ */
+async function gitClosePR(git, branch, author, message, validationToken) {
+    return gitClosePRRobust(git, branch, author, message);
+}
+/**
+ * Ferme un PR en utilisant Git Notes (avec fallback vers commit)
+ * Version robuste qui remplace gitClosePR
+ * @param git Instance Git
+ * @param branch Branche PR à fermer
+ * @param closedBy Utilisateur qui ferme le PR
+ * @param message Message optionnel à ajouter avant le token de validation
+ * @param config Configuration Git (optionnel, utilise la config globale)
+ * @returns Hash du commit de fermeture ou référence de la note
+ */
+async function gitClosePRRobust(git, branch, closedBy, message, config) {
+    const gitConf = (0, repo_tools_1.gitLoad)(config);
+    // Validation des paramètres
+    if (!branch) {
+        throw new errors_1.PRClosureError('Branch name is required', branch, 'invalid_parameters');
+    }
+    if (!closedBy) {
+        throw new errors_1.PRClosureError('Closed by is required', branch, 'invalid_parameters');
+    }
+    if (!branch.startsWith(gitConf.validationPrefix)) {
+        throw new errors_1.PRClosureError(`Branch must start with ${gitConf.validationPrefix}`, branch, 'invalid_branch');
+    }
+    //
+    // lock checkout is global
+    await (0, repo_tools_1.lock)('checkout');
+    let currentBranch;
+    try {
+        currentBranch = await git.revparse(['--abbrev-ref', 'HEAD']);
+        // 1. Read the existing metadata from the PR branch (includes search in recent commits)
+        const originalMetadata = await gitGetPRMetadata(git, branch, config);
+        if (!originalMetadata) {
+            throw new errors_1.PRClosureError(`Could not find metadata on branch ${branch}. Cannot close.`, branch, 'metadata_not_found');
+        }
+        // 3. Update the metadata note on the PR branch itself to mark it as closed
+        const finalMetadata = {
+            ...originalMetadata,
+            status: 'closed',
+            closedBy: closedBy,
+            closedAt: new Date().toISOString(),
+            comments: [...(originalMetadata.comments || []), message || ''],
+        };
+        // Get the commit hash of the HEAD of the branch
+        const headCommitHash = (await git.revparse([branch])).trim();
+        await (0, repo_tools_1.gitWriteNote)(git, headCommitHash, finalMetadata, gitConf.gitNotes.namespace);
+        // 4. Now, merge the updated PR branch into the target branch
+        await git.checkout(originalMetadata.mergeBase || gitConf.draftBranch);
+        const mergeResult = await git
+            .env({
+            GIT_AUTHOR_NAME: closedBy.name,
+            GIT_AUTHOR_EMAIL: closedBy.email,
+            GIT_COMMITTER_NAME: closedBy.name,
+            GIT_COMMITTER_EMAIL: closedBy.email,
+        })
+            .merge([
+            '--no-ff', '-X', 'theirs', '-m', `Merge branch '${branch}'`, branch
+        ]);
+        const result = {
+            metadata: finalMetadata,
+            failed: false,
+            conflicts: mergeResult.conflicts,
+            raw: mergeResult,
+        };
+        return result;
+    }
+    catch (error) {
+        if (error instanceof errors_1.PRClosureError)
+            throw error;
+        throw new errors_1.PRClosureError(`Failed to close PR ${branch}: ${error}`, branch, 'unknown');
+    }
+    finally {
+        if (currentBranch) {
+            await git.checkout(currentBranch);
+        }
+        (0, repo_tools_1.unlock)('checkout');
+    }
+}
+/**
+ * Trouve le prochain numéro de PR disponible (protégé contre la concurrence)
+ * @param git Instance Git
+ * @param validationPrefix Préfixe des branches de validation
+ * @returns Prochain numéro de PR
+ */
+async function gitGetNextPRNumber(git, validationPrefix) {
+    await (0, repo_tools_1.lock)('pr-number');
+    try {
+        const allBranches = await (0, repo_tools_1.gitGetAllBranches)(git);
+        const prBranches = allBranches.filter((branch) => branch.startsWith(validationPrefix));
+        if (prBranches.length === 0) {
+            return 1;
+        }
+        const numbers = prBranches
+            .map((branch) => {
+            const numberPart = branch.substring(validationPrefix.length);
+            // Gérer les cas où le nom de branche contient plus que le numéro après le préfixe
+            const actualNumber = parseInt(numberPart.split('-')[0], 10);
+            return actualNumber;
+        })
+            .filter((num) => !isNaN(num));
+        return numbers.length > 0 ? Math.max(...numbers) + 1 : 1;
+    }
+    catch (error) {
+        throw new errors_1.GitOperationError(`Failed to get next PR number: ${error}`, 'pr_number', { validationPrefix, originalError: error });
+    }
+    finally {
+        (0, repo_tools_1.unlock)('pr-number');
+    }
+}
+/**
+ * Crée une nouvelle branche de validation (pour un PR vers rule-editor)
+ * à partir d'une branche source (typiquement rule-editor).
+ * Fait un commit initial vide et écrit une note Git avec les métadonnées du travail à faire.
+ * @param git Instance SimpleGit
+ * @param files Liste des fichiers qui seront concernés par ce travail de validation
+ * @param description Description du travail ou du PR
+ * @param author Utilisateur qui initie ce travail
+ * @param options Options (content when file creation, editorBranch, validationBranchPrefix)
+ * @returns PRInfo contenant les informations de la branche créée et ses métadonnées initiales
+ */
+async function gitNewValidationRequest(git, files, description, author, options = {}) {
+    await (0, repo_tools_1.lock)('new-pr');
+    let currentBranch;
+    try {
+        currentBranch = await git.revparse(['--abbrev-ref', 'HEAD']);
+        const gitConfig = (0, repo_tools_1.gitLoad)();
+        const { content = options.content || [], editorBranch: sourceBranch = options.editorBranch || gitConfig.draftBranch, validationBranchPrefix = options.validationBranchPrefix || gitConfig.validationPrefix } = options;
+        if ((!files || !files.length)) {
+            throw new errors_1.PRCreationError('At least one file must be specified for a new validation branch');
+        }
+        if (!author) {
+            throw new errors_1.PRCreationError('Author is required', undefined, files);
+        }
+        try {
+            const nextID = await gitGetNextPRNumber(git, validationBranchPrefix);
+            const newBranchName = `${validationBranchPrefix}${nextID}`;
+            await git.checkoutBranch(newBranchName, sourceBranch);
+            const initialCommitMessage = `#${nextID} ${description}`;
+            // create or update files
+            for (let idx = 0; idx < files.length; idx++) {
+                if (!content[idx]) {
+                    continue;
+                }
+                // console.log('writeFile',files[idx],content[idx]);
+                // This writeFile is in-memory and stages the file.
+                await _writeFileAndCommit(git, files[idx], content[idx], author, gitConfig, initialCommitMessage);
+            }
+            const metadata = {
+                id: nextID,
+                status: 'open',
+                timestamp: new Date().toISOString(),
+                validator: '',
+                readyForValidation: false,
+                createdBy: author,
+                mergeBase: options.mergeBase || sourceBranch,
+                comments: [description || `Write description here...`],
+                files: files,
+            };
+            // Get the commit hash of the HEAD of the new branch
+            const headCommitHash = (await git.revparse([newBranchName])).trim();
+            await (0, repo_tools_1.gitWriteNote)(git, headCommitHash, metadata, gitConfig.gitNotes.namespace);
+            const log = await git.log({ from: newBranchName, to: newBranchName, maxCount: 1 });
+            const lastCommit = log.latest;
+            return {
+                branch: newBranchName,
+                files: files,
+                open: true,
+                metadata: metadata,
+                lastCommit: lastCommit?.hash,
+                lastCommitMessage: lastCommit?.message,
+                lastModified: lastCommit?.date ? new Date(lastCommit.date) : undefined,
+                toString() { return this.branch; }
+            };
+        }
+        catch (error) {
+            if (error instanceof errors_1.PRCreationError || error instanceof errors_1.GitOperationError) {
+                throw error;
+            }
+            // Utiliser la variable "files" définie dans la portée externe du try
+            throw new errors_1.PRCreationError(`Failed to create validation branch: ${error}`, undefined, files);
+        }
+    }
+    finally {
+        if (currentBranch) {
+            await git.checkout(currentBranch);
+        }
+        (0, repo_tools_1.unlock)('new-pr');
+    }
+}
+/**
+ * DEPRECATED
+ */
+async function gitNewPR(git, files, description, author, options = {}) {
+    return gitNewValidationRequest(git, files, description, author, options);
+}
+/**
+ * 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;
+};