agentic-api 2.0.31 → 2.0.314

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

@@ -33,6 +33,13 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.gitIDRegistryExists = gitIDRegistryExists;
+exports.gitGenerateNextID = gitGenerateNextID;
+exports.gitReloadIDRegistry = gitReloadIDRegistry;
+exports.gitRegisterExistingID = gitRegisterExistingID;
+exports.gitIDRegistryRename = gitIDRegistryRename;
+exports.gitEnsureMatterID = gitEnsureMatterID;
+exports.gitFileStrictMatter = gitFileStrictMatter;
 exports.gitEnsureRepositoryConfiguration = gitEnsureRepositoryConfiguration;
 exports.gitEnsureRemoteConfiguration = gitEnsureRemoteConfiguration;
 exports.gitInit = gitInit;
@@ -51,6 +58,486 @@ const errors_1 = require("../errors");
 const path_1 = require("path");
 const fs = __importStar(require("fs/promises"));
 const repo_tools_1 = require("./repo.tools");
+/**
+ * Service singleton pour gérer le registre d'IDs en mémoire
+ */
+class IDRegistryService {
+    constructor() {
+        this.registry = null;
+        this.repoPath = '';
+        this.isDirty = false;
+    }
+    static get() {
+        return IDRegistryService.instance || (IDRegistryService.instance = new IDRegistryService());
+    }
+    /**
+     * Initialise le service avec le chemin du repository
+     */
+    init(repoPath) {
+        // Skip if already initialized
+        if (this.registry) {
+            return;
+        }
+        if (this.repoPath !== repoPath || !this.registry) {
+            this.repoPath = repoPath;
+            this.registry = this.loadFromDisk();
+            this.isDirty = false;
+        }
+    }
+    /**
+     * Force le rechargement du registre depuis le disque
+     * Utilisé principalement pour les tests qui simulent un redémarrage
+     */
+    forceReload() {
+        if (!this.repoPath) {
+            throw new Error('IDRegistryService not initialized. Call init() first.');
+        }
+        this.registry = this.loadFromDisk();
+        this.isDirty = false;
+    }
+    /**
+     * Charge le registre depuis le disque
+     */
+    loadFromDisk() {
+        const registryPath = (0, path_1.join)(this.repoPath, '.git', 'with-ids.json');
+        if (!(0, fs_1.existsSync)(registryPath)) {
+            return {
+                last: 980,
+                used: [],
+                updated: new Date().toISOString(),
+                matters: {}
+            };
+        }
+        try {
+            const data = JSON.parse((0, fs_1.readFileSync)(registryPath, 'utf8'));
+            // Migration : ajouter matters si absent (compatibilité anciens registres)
+            if (!data.matters) {
+                data.matters = {};
+            }
+            return data;
+        }
+        catch (error) {
+            console.warn('⚠️ Registre d\'IDs corrompu, création d\'un nouveau');
+            return {
+                last: 980,
+                used: [],
+                updated: new Date().toISOString(),
+                matters: {}
+            };
+        }
+    }
+    /**
+     * Sauvegarde le registre sur le disque (seulement si modifié)
+     */
+    save() {
+        if (!this.registry || !this.isDirty) {
+            return;
+        }
+        const gitDir = (0, path_1.join)(this.repoPath, '.git');
+        const registryPath = (0, path_1.join)(gitDir, 'with-ids.json');
+        // S'assurer que le répertoire .git existe
+        if (!(0, fs_1.existsSync)(gitDir)) {
+            console.warn(`⚠️ Cannot save ID registry: .git directory not found at ${this.repoPath}`);
+            return; // Ne pas sauvegarder si le repo n'est pas initialisé
+        }
+        try {
+            this.registry.updated = new Date().toISOString();
+            (0, fs_1.writeFileSync)(registryPath, JSON.stringify(this.registry, null, 2), 'utf8');
+            this.isDirty = false;
+        }
+        catch (error) {
+            console.warn(`⚠️ Failed to save ID registry:`, error);
+            // Ne pas propager l'erreur, le registre est une optimisation
+        }
+    }
+    /**
+     * Récupère le registre (lecture seule)
+     */
+    getRegistry() {
+        if (!this.registry) {
+            throw new Error('IDRegistryService not initialized. Call init() first.');
+        }
+        return this.registry;
+    }
+    /**
+     * Génère un nouvel ID unique
+     */
+    generateNextID() {
+        if (!this.registry) {
+            throw new Error('IDRegistryService not initialized. Call init() first.');
+        }
+        const newID = this.registry.last + 20;
+        this.registry.last = newID;
+        this.registry.used.push(newID);
+        this.isDirty = true;
+        return newID;
+    }
+    /**
+     * Vérifie si un ID appartient déjà à un fichier spécifique
+     */
+    isIDOwnedByFile(id, branch, file) {
+        if (!this.registry) {
+            return false;
+        }
+        const cacheKey = `${branch}:${file}`;
+        const cachedMatter = this.registry.matters[cacheKey];
+        return cachedMatter?.id === id;
+    }
+    /**
+     * Enregistre un ID existant
+     *
+     * @param id L'ID à enregistrer
+     * @param branch Branche du fichier (optionnel, pour vérification de propriété)
+     * @param file Nom du fichier (optionnel, pour vérification de propriété)
+     * @throws Error si l'ID est déjà utilisé par un autre fichier
+     */
+    registerExistingID(id, branch, file) {
+        if (!this.registry) {
+            throw new Error('IDRegistryService not initialized. Call init() first.');
+        }
+        // Si l'ID est déjà utilisé
+        if (this.registry.used.includes(id)) {
+            // Vérifier si c'est le même fichier (pas un doublon)
+            if (branch && file && this.isIDOwnedByFile(id, branch, file)) {
+                // Même fichier → OK, pas d'erreur
+                return;
+            }
+            // ID utilisé par un autre fichier → Erreur
+            const error = new Error(`ID ${id} est déjà utilisé`);
+            error.code = 'id_already_used';
+            throw error;
+        }
+        // Nouvel ID → Enregistrer
+        this.registry.used.push(id);
+        if (id > this.registry.last) {
+            this.registry.last = id;
+        }
+        this.isDirty = true;
+    }
+    /**
+     * Récupère un matter depuis le cache
+     * Note: Le champ 'updated' est filtré pour ne pas être exposé à l'extérieur
+     */
+    getMatterCache(branch, file) {
+        if (!this.registry) {
+            throw new Error('IDRegistryService not initialized. Call init() first.');
+        }
+        const cacheKey = `${branch}:${file}`;
+        const cached = this.registry.matters[cacheKey];
+        if (!cached) {
+            return undefined;
+        }
+        // Retourner uniquement les champs publics (sans 'updated')
+        return {
+            id: cached.id,
+            title: cached.title,
+            service: cached.service,
+            oldfile: cached.oldfile // FIXME (check if needed) ✅ Inclure oldfile temporaire si présent
+        };
+    }
+    /**
+     * Met à jour le cache d'un matter
+     */
+    setMatterCache(branch, file, matter) {
+        if (!this.registry) {
+            throw new Error('IDRegistryService not initialized. Call init() first.');
+        }
+        const cacheKey = `${branch}:${file}`;
+        this.registry.matters[cacheKey] = {
+            id: matter.id,
+            title: matter.title,
+            service: matter.service,
+            oldfile: matter.oldfile, // ✅ Inclure oldfile temporaire
+            updated: new Date().toISOString()
+        };
+        this.isDirty = true;
+    }
+    /**
+     * Supprime une entrée du cache
+     */
+    deleteMatterCache(branch, file) {
+        if (!this.registry) {
+            throw new Error('IDRegistryService not initialized. Call init() first.');
+        }
+        const cacheKey = `${branch}:${file}`;
+        delete this.registry.matters[cacheKey];
+        this.isDirty = true;
+    }
+    /**
+     * Renomme une entrée dans le cache du registre
+     *
+     * Cette méthode gère le renommage d'un fichier dans le cache:
+     * - Supprime l'ancienne clé `${branch}:${oldFile}`
+     * - Crée une nouvelle clé `${branch}:${newFile}` avec les mêmes données
+     * - Préserve l'ID et les métadonnées
+     *
+     * @param oldFile Ancien nom du fichier
+     * @param newFile Nouveau nom du fichier
+     * @param branch Branche concernée
+     *
+     * @example
+     * ```typescript
+     * // Après un rename Git
+     * idRegistryService.rename('old-name.md', 'new-name.md', 'rule-validation-1');
+     * ```
+     */
+    rename(oldFile, newFile, branch) {
+        if (!this.registry) {
+            throw new Error('IDRegistryService not initialized. Call init() first.');
+        }
+        const oldKey = `${branch}:${oldFile}`;
+        const newKey = `${branch}:${newFile}`;
+        // Récupérer le cache existant
+        const cached = this.registry.matters[oldKey];
+        if (!cached) {
+            // Pas de cache pour l'ancien fichier, rien à renommer
+            return;
+        }
+        // Supprimer l'ancienne clé
+        delete this.registry.matters[oldKey];
+        //
+        // Créer la nouvelle clé avec les mêmes données
+        // ⚠️ NE PAS inclure oldfile - c'est temporaire uniquement pour notification client
+        this.registry.matters[newKey] = {
+            id: cached.id,
+            title: cached.title,
+            service: cached.service,
+            updated: new Date().toISOString()
+        };
+        this.isDirty = true;
+    }
+}
+IDRegistryService.instance = null;
+// ✅ Instance singleton du service
+const idRegistryService = IDRegistryService.get();
+/**
+ * Vérifie si le fichier de registre d'IDs existe dans le repository Git
+ *
+ * Cette fonction est utile pour détecter si le système d'ID natif a été initialisé
+ * dans le repository. Le fichier `with-ids.json` est créé automatiquement lors du
+ * premier appel à `gitGenerateNextID()` ou `gitEnsureMatterID()`.
+ *
+ * @param config Configuration Git optionnelle (utilise la config par défaut si non fournie)
+ * @returns `true` si le fichier `.git/with-ids.json` existe, `false` sinon
+ *
+ * @example
+ * ```typescript
+ * const config = gitLoad({ repoPath: './my-repo' });
+ *
+ * if (gitIDRegistryExists(config)) {
+ *   console.log('Le registre d\'IDs existe déjà');
+ *   // On peut charger le registre existant
+ *   gitReloadIDRegistry(config);
+ * } else {
+ *   console.log('Première utilisation du système d\'IDs');
+ *   // Le registre sera créé au premier gitGenerateNextID()
+ * }
+ * ```
+ */
+function gitIDRegistryExists(config) {
+    const gitConf = (0, repo_tools_1.gitLoad)(config);
+    const registryPath = (0, path_1.join)(gitConf.repoPath, '.git', 'with-ids.json');
+    return (0, fs_1.existsSync)(registryPath);
+}
+/**
+ * Génère un nouvel ID unique en incrémentant de +20
+ * @param config Configuration Git optionnelle
+ * @returns Un nouvel ID unique
+ */
+function gitGenerateNextID(config) {
+    const gitConf = (0, repo_tools_1.gitLoad)(config);
+    idRegistryService.init(gitConf.repoPath);
+    const newID = idRegistryService.generateNextID();
+    idRegistryService.save();
+    return newID;
+}
+/**
+ * Force le rechargement du registre d'IDs depuis le disque
+ *
+ * **Utilisé principalement pour les tests qui simulent un redémarrage du serveur.**
+ *
+ * En production, cette fonction n'est pas nécessaire car le singleton est
+ * réinitialisé à chaque redémarrage du process Node.js.
+ *
+ * @param config Configuration Git optionnelle
+ *
+ * @example
+ * ```typescript
+ * // Dans un test : simuler un redémarrage
+ * await gitCreateOrEditFile(...); // Modifie le registre
+ * gitReloadIDRegistry(); // Force le rechargement depuis le disque
+ * ```
+ */
+function gitReloadIDRegistry(config) {
+    const gitConf = (0, repo_tools_1.gitLoad)(config);
+    idRegistryService.init(gitConf.repoPath);
+    idRegistryService.forceReload();
+}
+/**
+ * Enregistre un ID existant dans le registre
+ *
+ * @param id L'ID à enregistrer
+ * @param branch Branche du fichier (optionnel, pour vérification de propriété)
+ * @param file Nom du fichier (optionnel, pour vérification de propriété)
+ * @param config Configuration Git optionnelle
+ * @throws GitOperationError si l'ID est déjà utilisé par un autre fichier
+ *
+ * **Note:** Si `branch` et `file` sont fournis, la fonction vérifie si l'ID appartient
+ * déjà au même fichier. Si oui, aucune erreur n'est levée (cas de re-scan).
+ */
+function gitRegisterExistingID(id, branch, file, config) {
+    const gitConf = (0, repo_tools_1.gitLoad)(config);
+    idRegistryService.init(gitConf.repoPath);
+    idRegistryService.registerExistingID(id, branch, file);
+    idRegistryService.save();
+}
+/**
+ * Renomme un fichier dans le cache du registre d'IDs
+ *
+ * Cette fonction met à jour le cache lorsqu'un fichier est renommé:
+ * - Supprime l'entrée avec l'ancien nom
+ * - Crée une nouvelle entrée avec le nouveau nom
+ * - Préserve l'ID et les métadonnées
+ *
+ * @param oldFile Ancien nom du fichier
+ * @param newFile Nouveau nom du fichier
+ * @param branch Branche concernée
+ * @param config Configuration Git optionnelle
+ *
+ * @example
+ * ```typescript
+ * // Après un rename dans Git
+ * gitIDRegistryRename('procedure-old.md', 'procedure-new.md', 'rule-validation-1');
+ * ```
+ */
+function gitIDRegistryRename(oldFile, newFile, branch, config) {
+    const gitConf = (0, repo_tools_1.gitLoad)(config);
+    idRegistryService.init(gitConf.repoPath);
+    idRegistryService.rename(oldFile, newFile, branch);
+    idRegistryService.save();
+}
+/**
+ * Valide et assure qu'un matter a un ID valide
+ * @param matter Le matter à valider/compléter
+ * @param config Configuration Git optionnelle
+ * @returns Le matter mis à jour avec un ID valide
+ */
+function gitEnsureMatterID(matter, config) {
+    // Si ID existe et est valide
+    // FIXME 999 should be a constant in config
+    if (matter.id && typeof matter.id === 'number' && matter.id > 999) {
+        try {
+            // Pas de branch/file car utilisé pour nouveaux fichiers ou contexte inconnu
+            gitRegisterExistingID(matter.id, undefined, undefined, config);
+            return matter;
+        }
+        catch (error) {
+            // ID déjà utilisé → générer un nouveau (silencieux, géré par le caller)
+        }
+    }
+    // Générer un nouvel ID
+    matter.id = gitGenerateNextID(config);
+    return matter;
+}
+/**
+ * Valide le format du matter (ID et title obligatoires)
+ * @param matter Le matter à valider
+ * @throws GitOperationError si le matter est invalide
+ */
+function validateMatter(matter) {
+    if (!matter || typeof matter !== 'object') {
+        throw new errors_1.GitOperationError('Le matter est invalide', 'invalid_matter');
+    }
+    //
+    // ✅ FIX: Vérifier que l'ID existe et est un nombre
+    if (!matter.id || typeof matter.id !== 'number') {
+        throw new errors_1.GitOperationError('Le matter doit contenir un champ "id" de type number', 'missing_id', { matter });
+    }
+    if (matter.id <= 999) {
+        throw new errors_1.GitOperationError(`L'ID ${matter.id} est réservé (doit être >= 1000)`, 'invalid_id', { id: matter.id });
+    }
+    if (!matter.title || typeof matter.title !== 'string') {
+        throw new errors_1.GitOperationError('Le matter doit contenir un champ "title" de type string', 'missing_title', { matter });
+    }
+}
+/**
+ * Extraction rapide du matter depuis une chaîne de contenu (helper interne)
+ * @internal
+ */
+function extractMatterFromContent(content) {
+    if (!content) {
+        return { id: 0, title: undefined, service: undefined, oldfile: undefined };
+    }
+    // Regex pour extraire id (format: "id: 1234" ou "id: '1234'")
+    const idMatch = content.match(/^id:\s*['"]?(\d+)['"]?/m);
+    const id = idMatch ? parseInt(idMatch[1], 10) : undefined;
+    // Regex pour extraire title (format: "title: Mon Titre" ou "title: 'Mon Titre'")
+    const titleMatch = content.match(/^title:\s*["']?([^"'\n]+)["']?/m);
+    const title = titleMatch ? titleMatch[1].trim() : undefined;
+    const serviceMatch = content.match(/^service:\s*["']?([^"'\n]+)["']?/m);
+    const service = serviceMatch ? serviceMatch[1].trim() : undefined;
+    //
+    // ✅ Extraction de oldfile (champ temporaire pour notifier les renames)
+    const oldfileMatch = content.match(/^oldfile:\s*["']?([^"'\n]+)["']?/m);
+    const oldfile = oldfileMatch ? oldfileMatch[1].trim() : undefined;
+    return { id, title, service, oldfile };
+}
+/**
+ * Lecture rapide et stricte du matter d'un fichier (id + title uniquement)
+ *
+ * **Optimisation : Utilise le cache du registre d'IDs pour éviter de lire le fichier.**
+ *
+ * Cette fonction :
+ * 1. Vérifie d'abord le cache dans `.git/with-ids.json`
+ * 2. Si absent ou invalidé, lit le fichier avec regex (pas de parsing complet)
+ * 3. Met à jour le cache automatiquement
+ *
+ * @param git Instance SimpleGit
+ * @param filePath Chemin du fichier
+ * @param branch Nom de la branche
+ * @param config Configuration Git optionnelle
+ * @returns { id, title } ou { id: undefined, title: undefined } si absent
+ *
+ * @example
+ * ```typescript
+ * const matter = await gitFileStrictMatter(git, 'doc.md', 'main');
+ * console.log(matter.id);    // 1234
+ * console.log(matter.title); // "Mon Document"
+ * ```
+ */
+async function gitFileStrictMatter(git, filePath, branch, config) {
+    const gitConf = (0, repo_tools_1.gitLoad)(config);
+    idRegistryService.init(gitConf.repoPath);
+    try {
+        // ✅ ÉTAPE 1: Vérifier le cache
+        const cached = idRegistryService.getMatterCache(branch, filePath);
+        if (cached) {
+            // Cache trouvé, retourner directement
+            return {
+                id: cached.id,
+                title: cached.title,
+                oldfile: cached.oldfile // ✅ Inclure oldfile temporaire
+            };
+        }
+        // ❌ ÉTAPE 2: Cache absent, lire le fichier
+        const content = await git.show([`${branch}:${filePath}`]);
+        if (!content) {
+            return { id: undefined, title: undefined, oldfile: undefined };
+        }
+        // ✅ ÉTAPE 3: Extraction rapide avec regex (sans matterParse complet)
+        const matter = extractMatterFromContent(content);
+        // ✅ ÉTAPE 4: Mettre à jour le cache
+        idRegistryService.setMatterCache(branch, filePath, matter);
+        idRegistryService.save();
+        return matter;
+    }
+    catch (error) {
+        if (gitConf.verbose) {
+            console.warn(`⚠️ Erreur lecture matter de ${filePath}:`, error);
+        }
+        return { id: undefined, title: undefined, oldfile: undefined };
+    }
+}
 /**
  * Vérifie et configure un repository Git existant pour s'assurer qu'il a la configuration requise
  * @param git Instance SimpleGit
@@ -391,6 +878,35 @@ async function gitCreateOrEditFile(git, filePath, PR, content, user, config) {
     let currentBranch;
     try {
         const gitConf = (0, repo_tools_1.gitLoad)(config);
+        // ===== VALIDATION DES IDs (si activée) =====
+        if (gitConf.withID) {
+            try {
+                // Import dynamique pour éviter les dépendances circulaires
+                const { matterParse, matterSerialize } = await Promise.resolve().then(() => __importStar(require('../utils.matter')));
+                const parsed = matterParse(content);
+                if (gitConf.strictID) {
+                    // Mode strict : valider que l'ID existe et est correct
+                    validateMatter(parsed.matter);
+                    // Enregistrer l'ID existant
+                    // ✅ Passer branch (PR) et file (filePath) pour vérifier propriété
+                    gitRegisterExistingID(parsed.matter.id, PR, filePath, gitConf);
+                }
+                else {
+                    // Mode permissif : générer l'ID si manquant
+                    parsed.matter = gitEnsureMatterID(parsed.matter, gitConf);
+                    // Re-sérialiser avec l'ID mis à jour
+                    content = matterSerialize(parsed.content, parsed.matter);
+                }
+            }
+            catch (error) {
+                if (error.code === 'id_already_used') {
+                    throw new errors_1.GitOperationError(`Impossible de créer le fichier: ${error.message}`, 'duplicate_id', { filePath, error });
+                }
+                // Propager les autres erreurs de validation
+                throw error;
+            }
+        }
+        // ===== FIN VALIDATION IDs =====
         //
         // secure main and draft branches (on production)
         if (!gitConf?.canForce && PR == gitConf.mainBranch) {
@@ -408,6 +924,26 @@ async function gitCreateOrEditFile(git, filePath, PR, content, user, config) {
         // 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}`);
+        // ✅ Mettre à jour le cache du matter après sauvegarde
+        // NOTE: Le cache est TOUJOURS mis à jour, indépendamment de withID
+        // C'est une opération de cache, pas une validation
+        try {
+            const { matterParse } = await Promise.resolve().then(() => __importStar(require('../utils.matter')));
+            const parsed = matterParse(content);
+            idRegistryService.init(gitConf.repoPath);
+            idRegistryService.setMatterCache(PR, filePath, {
+                id: parsed.matter.id,
+                title: parsed.matter.title
+                // ⚠️ Ne PAS persister oldfile dans le cache - temporaire uniquement pour client
+            });
+            idRegistryService.save();
+        }
+        catch (cacheError) {
+            // Erreur non critique, ne pas bloquer la sauvegarde
+            if (gitConf.verbose) {
+                console.warn('⚠️ Erreur mise à jour cache matter:', cacheError);
+            }
+        }
         if (!oldNote) {
             return {
                 hash: commit.commit,

package/dist/src/rules/git/repo.tools.d.ts

@@ -2,11 +2,32 @@ import { SimpleGit } from 'simple-git';
 import { RulesGitConfig, PRMetadata, GitCommitHistory, GitFileSummary } from '../types';
 export declare function lock(key: string): Promise<void>;
 export declare function unlock(key: string): void;
+/**
+ * Valide si une valeur est un entier valide pour un ID
+ *
+ * Un ID valide doit être:
+ * - Un nombre (type number)
+ * - Un entier (pas de décimales)
+ * - Supérieur à 999 (réservé pour les IDs système)
+ * - Fini (pas NaN, pas Infinity)
+ *
+ * @param id Valeur à valider
+ * @returns true si l'ID est valide, false sinon
+ *
+ * @example
+ * isValidInt(1234) // true
+ * isValidInt(999) // false (trop petit)
+ * isValidInt(1.5) // false (pas un entier)
+ * isValidInt(NaN) // false
+ * isValidInt("1234") // false (pas un nombre)
+ */
+export declare function isValidInt(id: any): boolean;
 /**
  * Configuration et initialisation du client Git
+ * @param defaultConfig Configuration partielle optionnelle pour override
  * @returns Configuration Git avec l'instance et les chemins
  */
-export declare function gitLoad(defaultConfig?: RulesGitConfig): RulesGitConfig;
+export declare function gitLoad(defaultConfig?: Partial<RulesGitConfig>): RulesGitConfig;
 /**
  * Récupère la prévisualisation d'un fichier depuis Git (opération bas niveau atomique),
  * sans les métadonnées.

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

@@ -35,6 +35,7 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.lock = lock;
 exports.unlock = unlock;
+exports.isValidInt = isValidInt;
 exports.gitLoad = gitLoad;
 exports.gitGetFilePreview = gitGetFilePreview;
 exports.gitGetFileContent = gitGetFileContent;
@@ -76,11 +77,50 @@ function unlock(key) {
         releasers.delete(key);
     }
 }
+/**
+ * Valide si une valeur est un entier valide pour un ID
+ *
+ * Un ID valide doit être:
+ * - Un nombre (type number)
+ * - Un entier (pas de décimales)
+ * - Supérieur à 999 (réservé pour les IDs système)
+ * - Fini (pas NaN, pas Infinity)
+ *
+ * @param id Valeur à valider
+ * @returns true si l'ID est valide, false sinon
+ *
+ * @example
+ * isValidInt(1234) // true
+ * isValidInt(999) // false (trop petit)
+ * isValidInt(1.5) // false (pas un entier)
+ * isValidInt(NaN) // false
+ * isValidInt("1234") // false (pas un nombre)
+ */
+function isValidInt(id) {
+    // Vérifier que c'est un nombre
+    if (typeof id !== 'number') {
+        return false;
+    }
+    // Vérifier que c'est un nombre fini (pas NaN, pas Infinity)
+    if (!Number.isFinite(id)) {
+        return false;
+    }
+    // Vérifier que c'est un entier
+    if (!Number.isInteger(id)) {
+        return false;
+    }
+    // Vérifier que c'est supérieur à 999
+    if (id <= 999) {
+        return false;
+    }
+    return true;
+}
 // Global variables for git config and instance
 let gitConfig;
 let git;
 /**
  * Configuration et initialisation du client Git
+ * @param defaultConfig Configuration partielle optionnelle pour override
  * @returns Configuration Git avec l'instance et les chemins
  */
 function gitLoad(defaultConfig) {
@@ -99,6 +139,13 @@ function gitLoad(defaultConfig) {
     const validationToken = defaultConfig?.validationToken || process.env.DEFAULT_VALIDATION_TOKEN;
     const sshKeyPath = process.env.GIT_SSH_KEY_PATH;
     const sshPassphrase = process.env.GIT_SSH_PASSPHRASE;
+    // Configuration de la validation des IDs
+    const withID = defaultConfig?.withID !== undefined
+        ? defaultConfig.withID
+        : process.env.GIT_WITH_ID == 'true';
+    const strictID = defaultConfig?.strictID !== undefined
+        ? defaultConfig.strictID
+        : process.env.GIT_STRICT_ID == 'true';
     if (!repoPath || !draftBranch || !uploadPath || !mainBranch || !validationToken) {
         throw new errors_1.GitConfigurationError(messages_1.i18nRules.git_config_incomplete, 'repoPath|draftBranch|uploadPath|mainBranch|validationToken');
     }
@@ -152,7 +199,9 @@ function gitLoad(defaultConfig) {
         remoteUrl,
         verbose,
         canForce: defaultConfig?.canForce,
-        reset: defaultConfig?.reset
+        reset: defaultConfig?.reset,
+        withID,
+        strictID
     };
     git = gitInstance;
     return gitConfig;