create-gef 1.0.0 → 1.1.0

package/generator/features/scaffold-gef.js

@@ -0,0 +1,158 @@
+// features/scaffold-gef.js — Application de la surcouche GEF au projet (Moteur de Templates)
+// Réf. Playbook §6 : Documentation Diátaxis. §1 : SRP
+
+import fs from 'fs';
+import path from 'path';
+import chalk from 'chalk';
+
+const DIATAXIS_DIRS = [
+  'docs/tutorials',
+  'docs/how-to',
+  'docs/reference',
+  'docs/explanation/adr',
+  'docs/research',
+  'src',
+  'tests',
+  'scripts',
+  'assets',
+  'infra',
+  'database',
+];
+
+function createDirectories(includeCI) {
+  const dirs = includeCI ? [...DIATAXIS_DIRS, '.github/workflows'] : DIATAXIS_DIRS;
+  dirs.forEach((d) => fs.mkdirSync(d, { recursive: true }));
+}
+
+/**
+ * Applique les règles de Hard Limits selon la sévérité choisie.
+ */
+function applyTemplating(content, strictness, language) {
+  let maxLines = '30';
+  let maxParams = '3';
+  let maxComplexity = '10';
+  let maxPayload = '1 Mo';
+  let isEnglish = language === 'English';
+
+  if (strictness.includes('Startup')) {
+    maxLines = '50';
+    maxParams = '4';
+    maxComplexity = '15';
+    maxPayload = '5 Mo';
+  } else if (strictness.includes('Mission Critical')) {
+    maxLines = '15';
+    maxParams = '2';
+    maxComplexity = '5';
+    maxPayload = '100 Ko';
+  }
+
+  let result = content
+    .replace(/{{MAX_LINES}}/g, maxLines)
+    .replace(/{{MAX_PARAMS}}/g, maxParams)
+    .replace(/{{MAX_COMPLEXITY}}/g, maxComplexity)
+    .replace(/{{MAX_PAYLOAD}}/g, maxPayload);
+
+  if (isEnglish) {
+    result = result.replace(/Ce prompt est à fournir/g, 'This prompt is to be provided');
+    result = result.replace(/Tu es une IA d'assistance/g, 'You are an AI coding assistant');
+    // Simple traduction rudimentaire pour les instructions racines
+    result = `[ENGLISH MODE ACTIVATED - ALL RESPONSES MUST BE IN ENGLISH]\n\n${result}`;
+  }
+
+  return result;
+}
+
+/**
+ * Copie le Playbook et les prompts IA avec le templating dynamique.
+ */
+export function copyAndTemplateGefAssets(gefDir, strictness, language) {
+  console.log(chalk.cyan('📚 Ajout du Playbook et des Prompts IA dynamiques...'));
+  fs.mkdirSync('.gef/prompts', { recursive: true });
+
+  const playbookSrc = path.join(gefDir, 'ENGINEERING_PLAYBOOK.md');
+  if (fs.existsSync(playbookSrc)) {
+    const raw = fs.readFileSync(playbookSrc, 'utf8');
+    fs.writeFileSync('.gef/ENGINEERING_PLAYBOOK.md', applyTemplating(raw, strictness, language));
+  }
+
+  const promptsSrc = path.join(gefDir, 'prompts');
+  if (fs.existsSync(promptsSrc)) {
+    fs.readdirSync(promptsSrc).forEach((p) => {
+      const raw = fs.readFileSync(path.join(promptsSrc, p), 'utf8');
+      fs.writeFileSync(path.join('.gef/prompts', p), applyTemplating(raw, strictness, language));
+    });
+  }
+}
+
+function createAdrTemplate(gefDir) {
+  const templateSrc = path.join(gefDir, 'generator', 'templates', 'adr-template.md');
+  const dest = 'docs/explanation/adr/0000-template.md';
+  if (fs.existsSync(templateSrc)) fs.copyFileSync(templateSrc, dest);
+}
+
+function createResearchLog(language) {
+  const isEn = language === 'English';
+  const dest = 'docs/research/RESEARCH_LOG.md';
+  if (fs.existsSync(dest)) return;
+  fs.writeFileSync(
+    dest,
+    isEn
+      ? `# Research Log\n> Document bug fixes here.\n\n## 1. <Title>\n- **Context:** \n- **Root Cause:** \n- **Resolution:** \n- **Lesson Learned:** \n`
+      : `# Research Log — Journal de bord scientifique\n> Documentez ici la résolution des bugs bloquants.\n\n## 1. <Titre>\n- **Contexte :** \n- **Cause Racine :** \n- **Résolution :** \n- **Leçon apprise :** \n`
+  );
+}
+
+function createProjectConfig(answers, gefDir) {
+  const templatePath = path.join(gefDir, 'PROJECT_CONFIG.template.md');
+  if (!fs.existsSync(templatePath)) return;
+
+  const dateStr = new Date().toLocaleString(answers.language === 'English' ? 'en-US' : 'fr-FR', { month: 'long', year: 'numeric' });
+  const content = fs.readFileSync(templatePath, 'utf-8')
+    .replace(/{{PROJECT_NAME}}/g, answers.projectName)
+    .replace(/{{STACK}}/g, answers.stack)
+    .replace(/{{PHASE}}/g, answers.phase)
+    .replace(/{{DATABASE}}/g, answers.database)
+    .replace(/{{CLOUD}}/g, answers.cloud)
+    .replace(/{{GIT_WORKFLOW}}/g, answers.gitWorkflow)
+    .replace(/{{LINTER}}/g, answers.linter)
+    .replace(/{{STRICTNESS}}/g, answers.strictness)
+    .replace(/{{LANGUAGE}}/g, answers.language)
+    .replace(/{{DATE}}/g, dateStr);
+
+  fs.writeFileSync('PROJECT_CONFIG.md', content);
+}
+
+function createReadme({ projectName, stack, cloud, database, gitWorkflow, strictness }) {
+  const header = `# ${projectName}\n\n## Fonctionnalités\n<À COMPLÉTER>\n\n## Architecture\n- Stack: ${stack}\n- Cloud: ${cloud}\n- DB: ${database}\n- Git: ${gitWorkflow}\n- Sévérité: ${strictness}\n`;
+  if (fs.existsSync('README.md')) {
+    const existing = fs.readFileSync('README.md', 'utf8');
+    fs.writeFileSync('README.md', header + '\n---\n*Généré initialement par le framework GEF:*\n' + existing);
+  } else {
+    fs.writeFileSync('README.md', header);
+  }
+}
+
+function createGitignore(stack) {
+  let content = '\n# GEF Standard\n.env\n.DS_Store\n';
+  if (stack.includes('Python')) content += '__pycache__/\nvenv/\n.venv/\n.pytest_cache/\n';
+
+  if (fs.existsSync('.gitignore')) {
+    fs.appendFileSync('.gitignore', content);
+  } else {
+    fs.writeFileSync('.gitignore', content);
+  }
+}
+
+export function scaffoldGef(answers, gefDir) {
+  console.log(chalk.yellow('\n📁 Application de la surcouche GEF...'));
+  createDirectories(answers.includeCI);
+  copyAndTemplateGefAssets(gefDir, answers.strictness, answers.language);
+  createAdrTemplate(gefDir);
+  createResearchLog(answers.language);
+  createProjectConfig(answers, gefDir);
+  createReadme(answers);
+  createGitignore(answers.stack);
+
+  if (!fs.existsSync('CHANGELOG.md')) fs.writeFileSync('CHANGELOG.md', '');
+  if (!fs.existsSync('LICENSE')) fs.writeFileSync('LICENSE', '');
+}

package/generator/features/scaffold-git.js

@@ -0,0 +1,138 @@
+// features/scaffold-git.js — Initialisation Git et installation des hooks dynamiques
+// Réf. Playbook : TBD ou GitHub Flow
+
+import fs from 'fs';
+import { execSync } from 'child_process';
+import chalk from 'chalk';
+
+/**
+ * Initialise le dépôt Git.
+ */
+function initGitRepo() {
+  if (fs.existsSync('.git')) return;
+  execSync('git init && git branch -M main', { stdio: 'ignore' });
+}
+
+/**
+ * Génère le script pre-push de manière dynamique selon le choix du workflow Git.
+ */
+function generatePrePush(gitWorkflow) {
+  const isGitHubFlow = gitWorkflow.includes('GitHub Flow');
+  let script = '#!/bin/bash\n# Hook: pre-push\n\nCURRENT_BRANCH=$(git rev-parse --abbrev-ref HEAD)\n\n';
+
+  if (isGitHubFlow) {
+    script += `# Sécurité GitHub Flow : Interdire les pushes directs sur main
+if [ "$CURRENT_BRANCH" = "main" ] || [ "$CURRENT_BRANCH" = "master" ]; then
+  echo -e "\\033[31mErreur: Push direct sur '$CURRENT_BRANCH' interdit.\\033[0m"
+  echo "Le projet utilise GitHub Flow. Utilisez des branches et des Pull Requests."
+  exit 1
+fi
+\n`;
+  } else {
+    script += `# Sécurité TBD : Pushes sur main autorisés.
+echo -e "\\033[34mInfo: Mode TBD, push sur $CURRENT_BRANCH autorisé.\\033[0m"\n\n`;
+  }
+
+  script += `if [ -f "package.json" ] && grep -q '"test"' package.json; then
+  npm test || { echo -e "\\033[31mErreur: Tests en échec. Push annulé.\\033[0m"; exit 1; }
+elif [ -f "Makefile" ] && grep -q "^test:" Makefile; then
+  make test || { echo -e "\\033[31mErreur: Tests en échec. Push annulé.\\033[0m"; exit 1; }
+fi\n\nexit 0\n`;
+  return script;
+}
+
+/**
+ * Génère le script pre-commit de manière dynamique.
+ */
+function generatePreCommit(linter, strictness) {
+  let fileLimit = 400;
+  let payloadLimitKb = 1000; // 1 Mo par défaut
+  if (strictness.includes('Startup')) {
+    fileLimit = 500;
+    payloadLimitKb = 5000; // 5 Mo
+  }
+  if (strictness.includes('Mission Critical')) {
+    fileLimit = 200;
+    payloadLimitKb = 100; // 100 Ko
+  }
+
+  let linterCmd = '';
+  if (linter.includes('ESLint')) linterCmd = 'npm run lint || { echo "Erreur Lint"; exit 1; }';
+  else if (linter.includes('Biome')) linterCmd = 'npx biome check . || { echo "Erreur Lint"; exit 1; }';
+  else if (linter.includes('Ruff')) linterCmd = 'ruff check . || { echo "Erreur Lint"; exit 1; }';
+
+  return `#!/bin/bash
+# Hook: pre-commit
+
+SECRETS=$(git diff --cached -G"(api_key|secret|token|password)[ ]*=[ ]*['\\\"][a-zA-Z0-9_\\\\-]+['\\\"]" --name-only)
+if [ -n "$SECRETS" ]; then
+  echo "Erreur: Potentiel secret en clair."
+  exit 1
+fi
+
+DEBUG_FILES=$(git diff --cached --name-only | grep -E "(^|/)(debug_|test_)" | grep -v "^tests/")
+if [ -n "$DEBUG_FILES" ]; then
+  echo "Erreur: Fichier de debug détecté hors de tests/."
+  exit 1
+fi
+
+${linterCmd ? `echo "Exécution du linter..."\n${linterCmd}` : ''}
+
+for file in $(git diff --cached --name-only); do
+  if [ -f "$file" ]; then
+    LINES=$(wc -l < "$file")
+    if [ "$LINES" -gt ${fileLimit} ]; then
+      echo "Avertissement: $file dépasse ${fileLimit} lignes."
+    fi
+
+    # Vérification du Payload (Taille Max)
+    SIZE_KB=$(du -k "$file" | cut -f1)
+    if [ "$SIZE_KB" -gt ${payloadLimitKb} ]; then
+      echo "Erreur: $file ($SIZE_KB Ko) dépasse la limite de taille autorisée (${payloadLimitKb} Ko) pour ce niveau de sévérité."
+      exit 1
+    fi
+  fi
+done
+
+exit 0
+`;
+}
+
+/**
+ * Génère et installe les hooks dynamiques dans le projet.
+ */
+function installDynamicHooks(gitWorkflow, linter, strictness) {
+  fs.mkdirSync('.git/hooks', { recursive: true });
+
+  const commitMsgScript = `#!/bin/bash
+COMMIT_MSG=$(cat $1)
+PATTERN="^(feat|fix|docs|chore|refactor|style|perf|test|release)(\\([a-zA-Z0-9_.-]+\\))?: (.*) \\(#[0-9]+\\)$"
+if [[ ! $COMMIT_MSG =~ $PATTERN ]]; then
+  echo "Erreur: Le message doit suivre Conventional Commits et inclure (#Ticket)."
+  exit 1
+fi
+exit 0
+`;
+
+  fs.writeFileSync('.git/hooks/commit-msg', commitMsgScript);
+  fs.writeFileSync('.git/hooks/pre-push', generatePrePush(gitWorkflow));
+  fs.writeFileSync('.git/hooks/pre-commit', generatePreCommit(linter, strictness));
+
+  try {
+    execSync('chmod +x .git/hooks/commit-msg .git/hooks/pre-commit .git/hooks/pre-push', { stdio: 'ignore' });
+  } catch (_) { /* Ignoré sur Windows */ }
+}
+
+/**
+ * Orchestre l'initialisation Git et l'installation des hooks.
+ */
+export function scaffoldGit(gefDir, gitWorkflow, linter, strictness) {
+  console.log(chalk.yellow('🔗 Initialisation Git et installation des hooks...'));
+  try {
+    initGitRepo();
+    installDynamicHooks(gitWorkflow, linter, strictness);
+    console.log(chalk.green('✅ Git initialisé et Hooks dynamiques générés.'));
+  } catch (_) {
+    console.log(chalk.red("Erreur lors de l'installation des hooks Git."));
+  }
+}

package/generator/features/scaffold-linter.js

@@ -0,0 +1,91 @@
+// features/scaffold-linter.js — Génération des configurations de linter dynamiques
+// Réf. Playbook : Code Quality
+
+import fs from 'fs';
+import { execSync } from 'child_process';
+import chalk from 'chalk';
+
+/**
+ * Configure ESLint et Prettier.
+ */
+function configureEslint(stack) {
+  console.log(chalk.yellow('🧹 Configuration de ESLint + Prettier...'));
+  const eslintConfig = {
+    env: { browser: true, es2021: true, node: true },
+    extends: ['eslint:recommended', 'prettier'],
+    parserOptions: { ecmaVersion: 'latest', sourceType: 'module' },
+    rules: {},
+  };
+  fs.writeFileSync('.eslintrc.json', JSON.stringify(eslintConfig, null, 2));
+  fs.writeFileSync('.prettierrc', '{\n  "semi": true,\n  "singleQuote": true,\n  "printWidth": 100\n}\n');
+  
+  if (fs.existsSync('package.json')) {
+    const pkg = JSON.parse(fs.readFileSync('package.json', 'utf8'));
+    pkg.scripts = pkg.scripts || {};
+    pkg.scripts.lint = 'eslint . && prettier --check .';
+    pkg.scripts['lint:fix'] = 'eslint . --fix && prettier --write .';
+    fs.writeFileSync('package.json', JSON.stringify(pkg, null, 2));
+  }
+}
+
+/**
+ * Configure Biome.
+ */
+function configureBiome() {
+  console.log(chalk.yellow('⚡ Configuration de Biome...'));
+  const biomeConfig = {
+    $schema: "https://biomejs.dev/schemas/1.8.3/schema.json",
+    formatter: {
+      enabled: true,
+      formatWithErrors: false,
+      indentStyle: "space",
+      indentWidth: 2,
+      lineWidth: 100
+    },
+    linter: {
+      enabled: true,
+      rules: { recommended: true }
+    }
+  };
+  fs.writeFileSync('biome.json', JSON.stringify(biomeConfig, null, 2));
+  
+  if (fs.existsSync('package.json')) {
+    const pkg = JSON.parse(fs.readFileSync('package.json', 'utf8'));
+    pkg.scripts = pkg.scripts || {};
+    pkg.scripts.lint = 'biome check .';
+    pkg.scripts['lint:fix'] = 'biome check --write .';
+    fs.writeFileSync('package.json', JSON.stringify(pkg, null, 2));
+  }
+}
+
+/**
+ * Configure Ruff pour Python.
+ */
+function configureRuff() {
+  console.log(chalk.yellow('🐍 Configuration de Ruff...'));
+  const ruffToml = `[lint]
+select = ["E", "F", "I"]
+ignore = []
+
+[format]
+quote-style = "double"
+indent-style = "space"
+`;
+  fs.writeFileSync('ruff.toml', ruffToml);
+}
+
+/**
+ * Orchestre la génération de la configuration du linter.
+ */
+export function scaffoldLinter(linterChoice, stack) {
+  if (linterChoice === 'Aucun' || !linterChoice) return;
+
+  try {
+    if (linterChoice.includes('ESLint')) configureEslint(stack);
+    else if (linterChoice.includes('Biome')) configureBiome();
+    else if (linterChoice.includes('Ruff')) configureRuff();
+    console.log(chalk.green('✅ Linter configuré.'));
+  } catch (err) {
+    console.log(chalk.red('Erreur lors de la configuration du linter.'));
+  }
+}

package/generator/features/scaffold-stack.js

@@ -0,0 +1,101 @@
+// features/scaffold-stack.js — Installation du framework principal
+// Réf. Playbook §1 : SRP — une fonction par stack, Guard Clauses, Early Return
+
+import fs from 'fs';
+import path from 'path';
+import { execSync } from 'child_process';
+import chalk from 'chalk';
+
+const EXPRESS_ENTRY = (port = 3000) => `const express = require('express');
+const cors = require('cors');
+require('dotenv').config();
+
+const app = express();
+const PORT = process.env.PORT || ${port};
+
+app.use(cors());
+app.use(express.json({ limit: '1mb' })); // Hard Limit Playbook §4 : 1Mo max
+
+app.get('/', (req, res) => res.json({ message: 'API prête.' }));
+
+app.listen(PORT, () => console.log(\`Serveur lancé sur http://localhost:\${PORT}\`));
+`;
+
+const FASTAPI_ENTRY = (projectName) => `from fastapi import FastAPI
+
+app = FastAPI(title="${projectName}")
+
+@app.get("/")
+def read_root():
+    return {"message": "API prête."}
+`;
+
+/**
+ * Lance le scaffolding du framework choisi.
+ * @param {string} stack
+ * @param {string} projectName
+ * @param {string} projectPath
+ */
+export function scaffoldStack(stack, projectName, projectPath) {
+  if (stack === 'Projet vide') return;
+
+  const handlers = {
+    'Next.js (React)': () => scaffoldNext(projectName, projectPath),
+    'React (Vite)': () => scaffoldVite(projectName, projectPath),
+    'API Node.js (Express)': () => scaffoldExpress(),
+    'API Python (FastAPI)': () => scaffoldFastapi(projectName),
+  };
+
+  const handler = handlers[stack];
+  if (!handler) return;
+
+  try {
+    handler();
+    console.log(chalk.green('\n✅ Framework installé.'));
+  } catch (_) {
+    console.log(chalk.red('\nErreur lors du scaffolding. Continuation avec la structure de base GEF.'));
+  }
+}
+
+function scaffoldNext(projectName, projectPath) {
+  console.log(chalk.magenta('\n▲  Lancement de create-next-app :\n'));
+  process.chdir(path.resolve(projectPath, '..'));
+  fs.rmdirSync(projectPath);
+  execSync(`npx create-next-app@latest ${projectName}`, { stdio: 'inherit' });
+  process.chdir(projectPath);
+  console.log(chalk.yellow('\n🎭 Installation de Playwright (E2E)...'));
+  execSync('npm init playwright@latest --yes -- --quiet --browser=chromium', { stdio: 'inherit' });
+}
+
+function scaffoldVite(projectName, projectPath) {
+  console.log(chalk.magenta('\n⚡ Lancement de create-vite :\n'));
+  process.chdir(path.resolve(projectPath, '..'));
+  fs.rmdirSync(projectPath);
+  execSync(`npm create vite@latest ${projectName}`, { stdio: 'inherit' });
+  process.chdir(projectPath);
+  console.log(chalk.yellow('\nInstallation des dépendances...'));
+  execSync('npm install', { stdio: 'inherit' });
+  console.log(chalk.yellow('\n🎭 Installation de Playwright (E2E)...'));
+  execSync('npm init playwright@latest --yes -- --quiet --browser=chromium', { stdio: 'inherit' });
+}
+
+function scaffoldExpress() {
+  console.log(chalk.magenta('\n📦 Initialisation de l\'API Node.js...\n'));
+  execSync('npm init -y', { stdio: 'ignore' });
+  execSync('npm install express cors dotenv', { stdio: 'inherit' });
+  fs.mkdirSync('src', { recursive: true });
+  fs.writeFileSync('src/index.js', EXPRESS_ENTRY());
+  const pkg = JSON.parse(fs.readFileSync('package.json', 'utf8'));
+  pkg.scripts = { start: 'node src/index.js', dev: 'node --watch src/index.js' };
+  fs.writeFileSync('package.json', JSON.stringify(pkg, null, 2));
+}
+
+function scaffoldFastapi(projectName) {
+  console.log(chalk.magenta('\n🐍 Initialisation de l\'API Python (FastAPI)...\n'));
+  const pythonCmd = process.platform === 'win32' ? 'python' : 'python3';
+  execSync(`${pythonCmd} -m venv venv`, { stdio: 'inherit' });
+  fs.writeFileSync('requirements.txt', 'fastapi\nuvicorn[standard]\npython-dotenv\n');
+  fs.mkdirSync('src', { recursive: true });
+  fs.writeFileSync('src/__init__.py', '');
+  fs.writeFileSync('src/main.py', FASTAPI_ENTRY(projectName));
+}

package/generator/features/update.js

@@ -0,0 +1,61 @@
+// features/update.js — Mise à jour d'un projet GEF existant
+// Réf. Playbook §1 : SRP — cette fonction met à jour les règles et hooks dynamiques.
+
+import fs from 'fs';
+import path from 'path';
+import chalk from 'chalk';
+import { copyAndTemplateGefAssets } from './scaffold-gef.js';
+import { scaffoldGit } from './scaffold-git.js';
+
+/**
+ * Lit le fichier de configuration pour en extraire une valeur avec Regex.
+ */
+function extractFromConfig(content, regex, fallback) {
+  const match = content.match(regex);
+  return match ? match[1].trim() : fallback;
+}
+
+/**
+ * Met à jour le Playbook, les prompts IA et les hooks Git
+ * d'un projet GEF existant vers la dernière version du framework,
+ * tout en respectant ses paramètres (Sévérité, Git Flow, etc.)
+ * @param {string} gefDir - Chemin absolu vers la racine du GEF
+ */
+export function runUpdate(gefDir) {
+  if (!fs.existsSync('.git')) {
+    console.log(chalk.red('Erreur: Ce dossier ne semble pas être un dépôt Git valide.'));
+    process.exit(1);
+  }
+
+  // 1. Trouver le fichier de configuration
+  const configPath = fs.existsSync('PROJECT_CONFIG.md') 
+    ? 'PROJECT_CONFIG.md' 
+    : 'PROJECT_CONFIG.template.md';
+
+  if (!fs.existsSync(configPath)) {
+    console.log(chalk.red('\nErreur: Impossible de trouver PROJECT_CONFIG.md ou PROJECT_CONFIG.template.md.'));
+    console.log(chalk.yellow('Astuce: Le GEF a besoin de ce fichier pour connaître le niveau de sévérité et la stratégie Git de ce projet afin de le mettre à jour sans tout casser.'));
+    process.exit(1);
+  }
+
+  // 2. Extraire l'environnement du projet
+  const content = fs.readFileSync(configPath, 'utf8');
+  const gitWorkflow = extractFromConfig(content, /- \*\*Workflow Git \*\*: (.*)/, 'GitHub Flow');
+  const strictness = extractFromConfig(content, /- \*\*Sévérité \(Hard Limits\) \*\*: (.*)/, 'Standard / Enterprise');
+  const linter = extractFromConfig(content, /- \*\*Linter \/ Formatter \*\*: (.*)/, 'Aucun');
+  const language = extractFromConfig(content, /- \*\*Langue par défaut \*\*: (.*)/, 'Français');
+
+  console.log(chalk.blue(`\nLecture de la configuration actuelle du projet :`));
+  console.log(`  - Sévérité : ${chalk.yellow(strictness)}`);
+  console.log(`  - Git Flow : ${chalk.yellow(gitWorkflow)}`);
+  console.log(`  - Linter   : ${chalk.yellow(linter)}`);
+  console.log(`  - Langue   : ${chalk.yellow(language)}\n`);
+
+  // 3. Regénérer les assets dynamiquement
+  console.log(chalk.yellow('🔄 Mise à jour dynamique des ressources GEF...'));
+  
+  copyAndTemplateGefAssets(gefDir, strictness, language);
+  scaffoldGit(gefDir, gitWorkflow, linter, strictness);
+
+  console.log(chalk.green.bold('\n🎉 Projet GEF mis à jour avec succès !'));
+}