agentic-api 1.0.5 → 2.0.26

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

@@ -0,0 +1,354 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitHealthManager = void 0;
+const git_1 = require("../git");
+/**
+ * Git Repository Health Manager
+ *
+ * Manages repository health diagnostics, repairs, and maintenance operations.
+ * Provides safe operations that protect user work by only allowing destructive
+ * operations on temporary validation branches.
+ */
+class GitHealthManager {
+    constructor(config) {
+        this.config = (0, git_1.gitLoad)(config);
+        this.git = this.config.instance;
+    }
+    /**
+     * Detects and resolves any ongoing merge states in the repository
+     * This should be called before any migration operations
+     *
+     * Uses the robust gitGetBranchHealth function to diagnose issues:
+     * - git merge --abort → abandonne tout merge en cours
+     * - git reset --hard HEAD → nettoie index + working directory
+     */
+    async repairRepository(branch) {
+        // CRITICAL FIX: Checkout sur la branche cible avant forceRepair()
+        // Sinon ensureSafeBranch() vérifie la branche courante (qui peut être 'main')
+        try {
+            await this.git.checkout(branch);
+        }
+        catch (checkoutError) {
+            // Si checkout normal échoue, forcer le checkout
+            console.log(`🔧 Checkout forcé vers ${branch}...`, checkoutError);
+        }
+        try {
+            // Use the robust health diagnostic function
+            const health = await (0, git_1.gitGetBranchHealth)(this.git, branch);
+            // If branch is healthy, show only one line
+            if (health.healthy) {
+                console.log(`✅ ${health.branch} est en bonne santé`);
+            }
+            // Display issues found
+            if (health.issues.length > 0) {
+                console.log(`❌ Problèmes détectés:`);
+                health.issues.forEach(issue => console.log(`   - ${issue}`));
+            }
+            // Display recommendations
+            if (health.recommendations.length > 0) {
+                console.log(`🔧 Réparations recommandées:`);
+                health.recommendations.forEach(rec => console.log(`   - ${rec}`));
+            }
+            // Perform repair using the two essential commands
+            const { mainBranch, draftBranch, validationPrefix } = this.config;
+            // PROTECTION: Permettre la réparation seulement sur les branches de validation
+            // Refuser sur les branches protégées (main, rule-editor) et sur toute branche non-validation
+            if ([mainBranch, draftBranch].includes(health.branch) || !health.branch.startsWith(validationPrefix)) {
+                console.log(`🚨 PROTECTION: Réparation refusée sur la branche '${health.branch}' - uniquement autorisée sur les branches '${validationPrefix}*'`);
+                return;
+            }
+            if (!health.healthy) {
+                console.log(`✅ Branche de validation détectée: '${health.branch}' - réparation automatique`);
+                this.forceRepair();
+            }
+            // Verify repair was successful
+            const healthAfterRepair = await (0, git_1.gitGetBranchHealth)(this.git, branch);
+            if (!healthAfterRepair.healthy) {
+                console.warn(`⚠️  Réparation partielle. Problèmes restants:`);
+                healthAfterRepair.issues.forEach(issue => console.log(`   - ${issue}`));
+            }
+            // Only show details if there are problems
+            // console.log(`🔧 Diagnostic de l'état du dépôt sur ${health.branch}...`);
+            // console.log(`📊 Branche: ${health.branch}`);
+            // console.log(`   Existe: ${health.exists ? '✅' : '❌'}`);
+            // console.log(`   Accessible: ${health.accessible ? '✅' : '❌'}`);
+            // console.log(`   Propre: ${health.clean ? '✅' : '❌'}`);
+            // console.log(`   Index lisible: ${health.indexReadable ? '✅' : '❌'}`);
+            // console.log(`   État global: ${health.healthy ? '✅ SAIN' : '⚠️  PROBLÉMATIQUE'}`);
+        }
+        catch (error) {
+            console.error(`❌ Échec du diagnostic/réparation${branch ? ` sur ${branch}` : ''}:`, error);
+            throw new Error(`Impossible de diagnostiquer ou réparer le dépôt: ${error.message}`);
+        }
+    }
+    /**
+     * Ensures we're on a safe branch before performing destructive operations
+     * Protects user work by refusing operations on main branches
+     */
+    async ensureSafeBranch() {
+        const currentBranch = await this.git.revparse(['--abbrev-ref', 'HEAD']);
+        const { mainBranch, draftBranch, validationPrefix } = this.config;
+        // Check if we're on a protected branch
+        if (currentBranch === mainBranch) {
+            throw new Error(`🚨 PROTECTION: git reset --hard HEAD INTERDIT sur la branche '${mainBranch}' (branche de production)`);
+        }
+        if (currentBranch === draftBranch) {
+            throw new Error(`🚨 PROTECTION: git reset --hard HEAD INTERDIT sur la branche '${draftBranch}' (contient le travail utilisateur)`);
+        }
+        // Only allow on validation branches (temporary)
+        if (!currentBranch.startsWith(validationPrefix)) {
+            throw new Error(`🚨 PROTECTION: git reset --hard HEAD autorisé UNIQUEMENT sur les branches '${validationPrefix}*' (branches temporaires). Branche courante: '${currentBranch}'`);
+        }
+        console.log(`✅ Branche sécurisée détectée: '${currentBranch}' - opération autorisée`);
+        return currentBranch;
+    }
+    /**
+     * Force repair when git status fails
+     * PROTECTED: Only works on validation branches to protect user work
+     */
+    async forceRepair() {
+        // SECURITY: Verify we're on a safe branch before destructive operations
+        await this.ensureSafeBranch();
+        try {
+            await this.git.raw(['merge', '--abort']);
+            console.log('  ✅ Merge abandonné (forcé)');
+        }
+        catch (abortError) {
+        }
+        try {
+            await this.git.raw(['reset', '--hard', 'HEAD']);
+            console.log('  ✅ Index et working directory nettoyés');
+        }
+        catch (resetError) {
+            throw new Error(`Échec du reset --hard: ${resetError}`);
+        }
+    }
+    /**
+     * Comprehensive health check for all important branches in the system
+     * Provides a complete overview of repository health
+     */
+    async diagnosticRepository() {
+        console.log('🏥 Diagnostic complet du dépôt...');
+        const results = [];
+        const { mainBranch, draftBranch, validationPrefix } = this.config;
+        try {
+            // Check main branch
+            const mainHealth = await (0, git_1.gitGetBranchHealth)(this.git, mainBranch);
+            results.push(mainHealth);
+            this.displayHealthSummary(mainHealth);
+            // Check draft branch
+            const draftHealth = await (0, git_1.gitGetBranchHealth)(this.git, draftBranch);
+            results.push(draftHealth);
+            this.displayHealthSummary(draftHealth);
+            // Check all validation branches
+            const allBranches = await (0, git_1.gitGetAllBranches)(this.git);
+            const validationBranches = allBranches.filter(b => b.startsWith(validationPrefix));
+            if (validationBranches.length > 0) {
+                for (const branch of validationBranches) {
+                    const health = await (0, git_1.gitGetBranchHealth)(this.git, branch);
+                    results.push(health);
+                    this.displayHealthSummary(health);
+                }
+            }
+            // Global summary
+            const healthyCount = results.filter(h => h.healthy).length;
+            const totalCount = results.length;
+            const problemCount = totalCount - healthyCount;
+            if (problemCount === 0) {
+                console.log(`✅ Toutes les branches (${totalCount}) sont en bonne santé`);
+            }
+            else {
+                console.log(`📊 Résumé: ${healthyCount}/${totalCount} branches saines, ${problemCount} nécessitent une attention`);
+                console.log('💡 Utilisez repairRepository(branchName) pour les réparer');
+            }
+            return results;
+        }
+        catch (error) {
+            console.error('❌ Erreur lors du diagnostic complet:', error);
+            throw new Error(`Diagnostic complet échoué: ${error.message}`);
+        }
+    }
+    /**
+     * Display a concise health summary for a branch
+     */
+    displayHealthSummary(health) {
+        if (health.healthy) {
+            console.log(`✅ ${health.branch}`);
+        }
+        else {
+            console.log(`⚠️  ${health.branch}: ${health.issues.slice(0, 2).join(', ')}${health.issues.length > 2 ? '...' : ''}`);
+        }
+    }
+    /**
+     * Synchronizes and repairs all validation branches with the editor branch
+     *
+     * This function updates existing validation branches to stay in sync with rule-editor,
+     * not merging rule-editor into validation branches.
+     *
+     * Handles:
+     * - Échecs de synchronisation → tentative de réparation par branche
+     * - Branches inaccessibles → git checkout -f + git reset --hard HEAD (protected)
+     * - Working directory sale → git reset --hard HEAD (protected)
+     * - Retry automatique après réparation
+     * - Branches irréparables → log d'intervention manuelle
+     */
+    async syncValidationBranches() {
+        const { validationPrefix } = this.config;
+        if (!validationPrefix) {
+            console.error("Erreur: Le préfixe de validation n'est pas configuré.");
+            return;
+        }
+        // FIXME: forceRepair should manage this issue.
+        // PROTECTION: Sauvegarder la branche courante pour y revenir à la fin
+        const originalBranch = await this.git.revparse(['--abbrev-ref', 'HEAD']).catch(() => 'main');
+        try {
+            const allBranches = await (0, git_1.gitGetAllBranches)(this.git, { unmergedOnly: true });
+            const validationBranches = allBranches.filter(b => b.startsWith(validationPrefix));
+            const user = {
+                name: 'repair',
+                email: 'olivier@evaletolab.ch',
+            };
+            if (validationBranches.length === 0) {
+                return;
+            }
+            console.log(`🔄 Synchronisation de ${validationBranches.length} branche(s) de validation...`);
+            for (const branch of validationBranches) {
+                try {
+                    await this.repairRepository(branch);
+                }
+                catch (error) {
+                    console.warn(`⚠️  Échec de la synchronisation de ${branch}: ${error.message}`);
+                    // Try to repair this specific branch
+                    try {
+                        console.log(`🔧 Tentative de réparation de la branche ${branch}...`);
+                        // SECURITY: Verify this is a validation branch before destructive operations
+                        if (!branch.startsWith(this.config.validationPrefix)) {
+                            throw new Error(`🚨 PROTECTION: Réparation refusée sur '${branch}' - uniquement autorisée sur les branches '${this.config.validationPrefix}*'`);
+                        }
+                        // Check if the branch is in a problematic state
+                        const currentBranch = await this.git.revparse(['--abbrev-ref', 'HEAD']);
+                        if (currentBranch !== branch) {
+                            try {
+                                await this.git.checkout(branch);
+                            }
+                            catch (checkoutError) {
+                                // If checkout fails due to merge state, reset the branch
+                                console.log(`🔧 Réinitialisation forcée de la branche ${branch}...`);
+                                await this.git.raw(['checkout', '-f', branch]);
+                                // Abort any ongoing merge
+                                await this.git.raw(['merge', '--abort']).catch(() => { });
+                            }
+                        }
+                        // SECURITY: Double-check we're on the correct validation branch before reset
+                        const finalBranch = await this.git.revparse(['--abbrev-ref', 'HEAD']);
+                        if (!finalBranch.startsWith(this.config.validationPrefix)) {
+                            throw new Error(`🚨 PROTECTION: Branche courante '${finalBranch}' n'est pas une branche de validation - reset --hard HEAD annulé`);
+                        }
+                        // Clean the working directory - reset --hard does it all (PROTECTED)
+                        console.log(`✅ Branche de validation confirmée: '${finalBranch}' - nettoyage autorisé`);
+                        await this.git.raw(['reset', '--hard', 'HEAD']);
+                        // Retry the sync
+                        await (0, git_1.gitSyncPR)(this.git, branch, user);
+                        console.log(`✅ ${branch} réparée et synchronisée`);
+                    }
+                    catch (repairError) {
+                        console.error(`❌ Impossible de réparer ${branch}: ${repairError.message}`);
+                        console.error(`📝 Cette branche nécessite une intervention manuelle`);
+                        throw repairError;
+                    }
+                }
+            }
+        }
+        finally {
+            // FIXME the final state is unknown
+            // PROTECTION: Revenir à la branche originale seulement si elle est sécurisée
+            try {
+                const currentBranch = await this.git.revparse(['--abbrev-ref', 'HEAD']).catch(() => '');
+                if (currentBranch !== originalBranch) {
+                    const { mainBranch, draftBranch, validationPrefix } = this.config;
+                    // Ne revenir à la branche originale que si elle est une branche de validation
+                    // Pour les branches protégées, rester sur la branche courante pour éviter les erreurs
+                    if (originalBranch.startsWith(validationPrefix)) {
+                        await this.git.checkout(originalBranch).catch(() => {
+                            console.warn(`⚠️  Impossible de revenir à la branche de validation '${originalBranch}'`);
+                        });
+                    }
+                    else if ([mainBranch, draftBranch].includes(originalBranch)) {
+                        console.log(`ℹ️  Branche originale '${originalBranch}' est protégée - reste sur '${currentBranch}' pour la sécurité`);
+                    }
+                }
+            }
+            catch (error) {
+                console.warn(`⚠️  Erreur lors du retour à la branche originale: ${error}`);
+            }
+        }
+    }
+    /**
+     * Migrates Git notes from the first commit of validation branches to the last one.
+     *
+     * Handles:
+     * - Notes déjà présentes sur HEAD → skip migration
+     * - Merge-base introuvable → skip branche avec warning
+     * - Notes orphelines sur anciens commits → copie vers HEAD + suppression
+     * - Branches sans historique de notes → ignore silencieusement
+     * - Erreurs de traitement par branche → continue avec les autres
+     */
+    async migrateNotes() {
+        const { mainBranch, validationPrefix, gitNotes } = this.config;
+        if (!validationPrefix || !gitNotes.namespace) {
+            console.error("Erreur: Le préfixe de validation ou le namespace des notes n'est pas configuré.");
+            return;
+        }
+        const allBranches = await (0, git_1.gitGetAllBranches)(this.git);
+        const validationBranches = allBranches.filter(b => b.startsWith(validationPrefix));
+        if (validationBranches.length === 0) {
+            return;
+        }
+        let migratedCount = 0;
+        let alreadyOkCount = 0;
+        for (const branch of validationBranches) {
+            try {
+                const lastCommit = (await this.git.revparse(branch)).trim();
+                // 1. Check if note is already on the last commit
+                const noteOnHead = await (0, git_1.gitReadNote)(this.git, lastCommit, gitNotes.namespace, 1);
+                if (noteOnHead) {
+                    alreadyOkCount++;
+                    continue;
+                }
+                // 2. Scan the branch history for a note
+                const mergeBase = (await this.git.raw('merge-base', mainBranch, branch)).trim();
+                if (!mergeBase) {
+                    console.log(`⚠️  ${branch}: Impossible de trouver un point de merge avec '${mainBranch}'. Ignoré.`);
+                    continue;
+                }
+                const revListOutput = await this.git.raw('rev-list', `${mergeBase}..${branch}`);
+                const branchCommits = revListOutput.split('\n').filter(Boolean);
+                let oldNoteCommit = null;
+                for (const commitHash of branchCommits) {
+                    const note = await (0, git_1.gitReadNote)(this.git, commitHash, gitNotes.namespace, 1);
+                    if (note) {
+                        oldNoteCommit = commitHash;
+                        break; // Found the first note, stop searching
+                    }
+                }
+                // 3. If a note was found on an old commit, migrate it
+                if (oldNoteCommit) {
+                    console.log(`🔄 ${branch}: Migration de la note de ${oldNoteCommit.substring(0, 8)} vers ${lastCommit.substring(0, 8)}...`);
+                    await this.git.raw('notes', '--ref', gitNotes.namespace, 'copy', '--force', oldNoteCommit, lastCommit);
+                    await (0, git_1.gitDeleteNote)(this.git, oldNoteCommit, gitNotes.namespace);
+                    console.log(`✅ ${branch}: Migration terminée`);
+                    migratedCount++;
+                }
+            }
+            catch (error) {
+                console.error(`❌ ${branch}: Erreur lors de la migration:`, error);
+                throw error;
+            }
+        }
+        // Summary only if there was work to do
+        if (migratedCount > 0 || alreadyOkCount !== validationBranches.length) {
+            console.log(`✅ Migration des notes terminée: ${migratedCount} migrées, ${alreadyOkCount} déjà OK`);
+        }
+    }
+}
+exports.GitHealthManager = GitHealthManager;

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

@@ -0,0 +1,129 @@
+import { RulesGitConfig, GitCommitHistory } from '../types';
+import { IGitOperations, IGitRepository } from '../types.helpers';
+/**
+ * Mock basique pour les opérations Git
+ * Peut être étendu dans les tests spécifiques
+ */
+export declare class MockGitOperations implements IGitOperations {
+    private mockData;
+    constructor(mockData?: {
+        files?: Record<string, Record<string, string>>;
+        branches?: string[];
+        fileExists?: Record<string, Record<string, boolean>>;
+        mergedFiles?: Record<string, boolean>;
+    });
+    getFileContent(filePath: string, branch?: string): Promise<GitCommitHistory | null>;
+    listFilesInBranch(branch: string, pattern?: string): Promise<string[]>;
+    fileExistsInBranch(filePath: string, branch: string): Promise<boolean>;
+    isFileMerged(filePath: string, from: string, target?: string): Promise<boolean>;
+    getAllBranches(): Promise<string[]>;
+    validateConfiguration(): Promise<boolean>;
+}
+/**
+ * Configuration pour les tests E2E
+ */
+export interface E2ETestConfig {
+    /**
+     * Répertoire temporaire pour les tests
+     */
+    tempDir: string;
+    /**
+     * Configuration Git pour les tests
+     */
+    gitConfig: RulesGitConfig;
+    /**
+     * Nettoyage automatique après les tests
+     */
+    autoCleanup: boolean;
+}
+/**
+ * Interface pour les opérations de test E2E
+ * Étend les interfaces existantes avec des méthodes spécifiques aux tests
+ */
+export interface IE2ETestOperations extends IGitRepository {
+    /**
+     * Initialise un repository Git temporaire pour les tests
+     */
+    initTemporaryRepo(): Promise<void>;
+    /**
+     * Nettoie le repository temporaire
+     */
+    cleanup(): Promise<void>;
+    /**
+     * Crée un fichier dans le repository
+     * @param filePath Chemin du fichier
+     * @param content Contenu du fichier
+     * @param branch Branche optionnelle (par défaut: draft)
+     */
+    createOrEditFile(filePath: string, content: string, branch?: string): Promise<GitCommitHistory>;
+    /**
+     * Modifie un fichier existant
+     * @param filePath Chemin du fichier
+     * @param content Contenu du fichier
+     * @param branch Branche optionnelle (par défaut: draft)
+     */
+    editFile(filePath: string, content: string, branch?: string): Promise<GitCommitHistory>;
+    /**
+     * Vérifie l'état du repository (intégrité, branches, etc.)
+     */
+    validateRepositoryState(): Promise<{
+        isValid: boolean;
+        branches: string[];
+        files: Record<string, string[]>;
+        errors: string[];
+    }>;
+    /**
+     * Simule un workflow complet de création et validation de PR
+     */
+    runCompleteWorkflow(files: {
+        path: string;
+        content: string;
+    }[], description: string): Promise<{
+        prBranch: string;
+        commitHash: string;
+        mergeCommitHash?: string;
+    }>;
+}
+/**
+ * Résultat d'un test E2E
+ */
+export interface E2ETestResult {
+    success: boolean;
+    duration: number;
+    details: {
+        repositoryValid: boolean;
+        filesCreated: string[];
+        prCreated?: string;
+        prClosed?: boolean;
+        merged?: boolean;
+    };
+    errors: string[];
+}
+/**
+ * Interface pour les assertions E2E spécifiques au domain rules
+ */
+export interface IRulesE2EAssertions {
+    /**
+     * Vérifie qu'un fichier existe et a le contenu attendu
+     */
+    assertFileContent(filePath: string, expectedContent: string, branch?: string): Promise<void>;
+    /**
+     * Vérifie qu'un PR existe et est dans l'état attendu
+     */
+    assertPRState(branch: string, expectedState: 'open' | 'closed'): Promise<void>;
+    /**
+     * Vérifie qu'un fichier a été mergé dans la branche principale
+     */
+    assertFilemerged(filePath: string, fromBranch: string, toBranch?: string): Promise<void>;
+    /**
+     * Vérifie la cohérence de l'historique Git
+     */
+    assertGitHistory(expectedCommits: {
+        message: string;
+        author?: string;
+    }[]): Promise<void>;
+    /**
+     * Vérifie que les branches ont été créées correctement
+     */
+    assertBranchStructure(expectedBranches: string[]): Promise<void>;
+}

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

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockGitOperations = void 0;
+// ===== INTERFACES MOCKABLES POUR LES TESTS =====
+// ===== CLASSES MOCK POUR LES TESTS =====
+/**
+ * Mock basique pour les opérations Git
+ * Peut être étendu dans les tests spécifiques
+ */
+class MockGitOperations {
+    constructor(mockData = {}) {
+        this.mockData = mockData;
+    }
+    async getFileContent(filePath, branch) {
+        const branchKey = branch || 'HEAD';
+        if (!this.mockData.files?.[branchKey]?.[filePath]) {
+            return null;
+        }
+        const commit = {
+            hash: 'mock-commit-hash',
+            date: new Date(),
+            message: 'Mock commi',
+            author: {
+                name: 'Mock Auor',
+                email: '@uhorcom'
+            },
+            content: this.mockData.files[branchKey][filePath],
+        };
+        return commit;
+    }
+    async listFilesInBranch(branch, pattern = '.md') {
+        const branchFiles = this.mockData.files?.[branch] || {};
+        const files = Object.keys(branchFiles);
+        if (pattern === '.md') {
+            return files.filter(file => file.endsWith('.md'));
+        }
+        const regex = new RegExp(pattern.replace('*', '.*'));
+        return files.filter(file => regex.test(file));
+    }
+    async fileExistsInBranch(filePath, branch) {
+        return this.mockData.fileExists?.[branch]?.[filePath] ?? false;
+    }
+    async isFileMerged(filePath, from, target = 'main') {
+        return this.mockData.mergedFiles?.[filePath] ?? false;
+    }
+    async getAllBranches() {
+        return this.mockData.branches || [];
+    }
+    async validateConfiguration() {
+        return true;
+    }
+}
+exports.MockGitOperations = MockGitOperations;

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

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

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

@@ -0,0 +1,76 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gitNewPR = exports.gitNewValidationRequest = exports.gitGetNextPRNumber = exports.gitClosePRRobust = exports.gitClosePR = exports.gitPRUpdateComments = exports.gitLoadPR = exports.gitGetClosedPRs = exports.gitGetAllPR = exports.gitGetPRMetadata = exports.gitIsPRClosedRobust = exports.gitIsPRClosed = exports.gitSyncPR = exports.gitDeleteFile = exports.gitRenameFile = exports.gitEditFile = exports.gitCreateOrEditFile = exports.gitGetBranchHealth = exports.gitCheckConfiguration = exports.gitShowConfiguration = exports.gitSetupRepository = exports.gitEnsureRemoteConfiguration = exports.gitEnsureRepositoryConfiguration = exports.gitInit = exports.gitDeleteNote = exports.gitWriteNote = exports.gitReadNote = exports.gitGetDiffFiles = exports.gitGetAllBranches = exports.gitGetUnmergedBranchesForFile = exports.gitReadFileOutsideRepo = exports.gitGetFileHistory = exports.gitGetFilePreview = exports.gitGetFileContent = exports.gitGetFilesSummary = exports.gitFileExistsInBranch = exports.gitListFilesOutsideRepo = exports.gitListFilesInBranch = exports.gitLastCommit = exports.gitIsFileMerged = exports.gitLoad = exports.unlock = exports.lock = void 0;
+// === OPÉRATIONS GIT BAS NIVEAU ===
+// Fonctions atomiques pour manipuler Git directement
+var repo_tools_1 = require("./repo.tools");
+// Concurrence
+Object.defineProperty(exports, "lock", { enumerable: true, get: function () { return repo_tools_1.lock; } });
+Object.defineProperty(exports, "unlock", { enumerable: true, get: function () { return repo_tools_1.unlock; } });
+// Configuration
+Object.defineProperty(exports, "gitLoad", { enumerable: true, get: function () { return repo_tools_1.gitLoad; } });
+// Lecture de fichiers
+Object.defineProperty(exports, "gitIsFileMerged", { enumerable: true, get: function () { return repo_tools_1.gitIsFileMerged; } });
+Object.defineProperty(exports, "gitLastCommit", { enumerable: true, get: function () { return repo_tools_1.gitLastCommit; } });
+Object.defineProperty(exports, "gitListFilesInBranch", { enumerable: true, get: function () { return repo_tools_1.gitListFilesInBranch; } });
+Object.defineProperty(exports, "gitListFilesOutsideRepo", { enumerable: true, get: function () { return repo_tools_1.gitListFilesOutsideRepo; } });
+Object.defineProperty(exports, "gitFileExistsInBranch", { enumerable: true, get: function () { return repo_tools_1.gitFileExistsInBranch; } });
+Object.defineProperty(exports, "gitGetFilesSummary", { enumerable: true, get: function () { return repo_tools_1.gitGetFilesSummary; } });
+Object.defineProperty(exports, "gitGetFileContent", { enumerable: true, get: function () { return repo_tools_1.gitGetFileContent; } });
+Object.defineProperty(exports, "gitGetFilePreview", { enumerable: true, get: function () { return repo_tools_1.gitGetFilePreview; } });
+Object.defineProperty(exports, "gitGetFileHistory", { enumerable: true, get: function () { return repo_tools_1.gitGetFileHistory; } });
+Object.defineProperty(exports, "gitReadFileOutsideRepo", { enumerable: true, get: function () { return repo_tools_1.gitReadFileOutsideRepo; } });
+// Gestion des branches
+Object.defineProperty(exports, "gitGetUnmergedBranchesForFile", { enumerable: true, get: function () { return repo_tools_1.gitGetUnmergedBranchesForFile; } });
+Object.defineProperty(exports, "gitGetAllBranches", { enumerable: true, get: function () { return repo_tools_1.gitGetAllBranches; } });
+Object.defineProperty(exports, "gitGetDiffFiles", { enumerable: true, get: function () { return repo_tools_1.gitGetDiffFiles; } });
+// Git Notes
+Object.defineProperty(exports, "gitReadNote", { enumerable: true, get: function () { return repo_tools_1.gitReadNote; } });
+Object.defineProperty(exports, "gitWriteNote", { enumerable: true, get: function () { return repo_tools_1.gitWriteNote; } });
+Object.defineProperty(exports, "gitDeleteNote", { enumerable: true, get: function () { return repo_tools_1.gitDeleteNote; } });
+var repo_1 = require("./repo");
+Object.defineProperty(exports, "gitInit", { enumerable: true, get: function () { return repo_1.gitInit; } });
+Object.defineProperty(exports, "gitEnsureRepositoryConfiguration", { enumerable: true, get: function () { return repo_1.gitEnsureRepositoryConfiguration; } });
+Object.defineProperty(exports, "gitEnsureRemoteConfiguration", { enumerable: true, get: function () { return repo_1.gitEnsureRemoteConfiguration; } });
+Object.defineProperty(exports, "gitSetupRepository", { enumerable: true, get: function () { return repo_1.gitSetupRepository; } });
+Object.defineProperty(exports, "gitShowConfiguration", { enumerable: true, get: function () { return repo_1.gitShowConfiguration; } });
+Object.defineProperty(exports, "gitCheckConfiguration", { enumerable: true, get: function () { return repo_1.gitCheckConfiguration; } });
+Object.defineProperty(exports, "gitGetBranchHealth", { enumerable: true, get: function () { return repo_1.gitGetBranchHealth; } });
+Object.defineProperty(exports, "gitCreateOrEditFile", { enumerable: true, get: function () { return repo_1.gitCreateOrEditFile; } });
+Object.defineProperty(exports, "gitEditFile", { enumerable: true, get: function () { return repo_1.gitEditFile; } });
+Object.defineProperty(exports, "gitRenameFile", { enumerable: true, get: function () { return repo_1.gitRenameFile; } });
+Object.defineProperty(exports, "gitDeleteFile", { enumerable: true, get: function () { return repo_1.gitDeleteFile; } });
+// === GESTION DES PULL REQUESTS (repo.pr.ts) ===
+var repo_pr_1 = require("./repo.pr");
+// Synchronisation et statut
+Object.defineProperty(exports, "gitSyncPR", { enumerable: true, get: function () { return repo_pr_1.gitSyncPR; } });
+Object.defineProperty(exports, "gitIsPRClosed", { enumerable: true, get: function () { return repo_pr_1.gitIsPRClosed; } });
+Object.defineProperty(exports, "gitIsPRClosedRobust", { enumerable: true, get: function () { return repo_pr_1.gitIsPRClosedRobust; } });
+Object.defineProperty(exports, "gitGetPRMetadata", { enumerable: true, get: function () { return repo_pr_1.gitGetPRMetadata; } });
+Object.defineProperty(exports, "gitGetAllPR", { enumerable: true, get: function () { return repo_pr_1.gitGetAllPR; } });
+Object.defineProperty(exports, "gitGetClosedPRs", { enumerable: true, get: function () { return repo_pr_1.gitGetClosedPRs; } });
+Object.defineProperty(exports, "gitLoadPR", { enumerable: true, get: function () { return repo_pr_1.gitLoadPR; } });
+// Opérations sur les PRs
+Object.defineProperty(exports, "gitPRUpdateComments", { enumerable: true, get: function () { return repo_pr_1.gitPRUpdateComments; } });
+Object.defineProperty(exports, "gitClosePR", { enumerable: true, get: function () { return repo_pr_1.gitClosePR; } });
+Object.defineProperty(exports, "gitClosePRRobust", { enumerable: true, get: function () { return repo_pr_1.gitClosePRRobust; } });
+Object.defineProperty(exports, "gitGetNextPRNumber", { enumerable: true, get: function () { return repo_pr_1.gitGetNextPRNumber; } });
+Object.defineProperty(exports, "gitNewValidationRequest", { enumerable: true, get: function () { return repo_pr_1.gitNewValidationRequest; } });
+Object.defineProperty(exports, "gitNewPR", { enumerable: true, get: function () { return repo_pr_1.gitNewPR; } });
+__exportStar(require("./git.e2e.helper"), exports);
+__exportStar(require("./git.health"), exports);
+__exportStar(require("./git.helper"), exports);