qwen-superpowers 1.0.0

package/cli/index.js

@@ -0,0 +1,335 @@
+#!/usr/bin/env node
+
+/**
+ * qwen-superpowers CLI
+ * Interface en ligne de commande pour gérer les skills et le workflow Qwen Superpowers.
+ */
+
+const path = require('path');
+const fs = require('fs');
+
+const ROOT_DIR = path.join(__dirname, '..');
+const SKILLS_DIR = path.join(ROOT_DIR, 'skills');
+const CONFIG_FILE = path.join(ROOT_DIR, '.qwen-powers.json');
+
+// ─── Couleurs CLI ────────────────────────────────────────────────
+const colors = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  red: '\x1b[31m',
+  cyan: '\x1b[36m',
+  gray: '\x1b[90m',
+};
+
+function colorize(color, text) {
+  return `${colors[color]}${text}${colors.reset}`;
+}
+
+// ─── Commandes ───────────────────────────────────────────────────
+
+const commands = {
+  help() {
+    const lines = [
+      '',
+      colorize('bold', colorize('cyan', '+---------------------------------------------------------+')),
+      colorize('bold', colorize('cyan', '|') + '          Qwen Superpowers CLI v1.0.0            ' + colorize('bold', colorize('cyan', '|'))),
+      colorize('bold', colorize('cyan', '+---------------------------------------------------------+')),
+      '',
+      colorize('bold', 'USAGE:'),
+      '  ' + colorize('green', 'qwen-powers') + ' <commande> [options]',
+      '',
+      colorize('bold', 'COMMANDES:'),
+      '  ' + colorize('yellow', 'list') + '                    Liste tous les skills disponibles',
+      '  ' + colorize('yellow', 'show') + ' <skill>            Affiche les details d\'un skill',
+      '  ' + colorize('yellow', 'init') + ' [target-dir]       Initialise le plugin dans un projet cible',
+      '  ' + colorize('yellow', 'enable') + ' <skill>          Active un skill dans la config locale',
+      '  ' + colorize('yellow', 'disable') + ' <skill>         Desactive un skill',
+      '  ' + colorize('yellow', 'workflow') + '                Affiche le workflow en 7 etapes',
+      '  ' + colorize('yellow', 'hook') + ' <name>             Execute un hook (pre-execute, post-execute)',
+      '  ' + colorize('yellow', 'update') + '                  Met a jour les skills depuis le depot',
+      '  ' + colorize('yellow', 'create') + ' <nom>            Cree un nouveau skill (squelette)',
+      '  ' + colorize('yellow', 'help') + '                    Affiche cette aide',
+      '',
+      colorize('bold', 'EXEMPLES:'),
+      '  ' + colorize('gray', 'qwen-powers list'),
+      '  ' + colorize('gray', 'qwen-powers show test-driven-development'),
+      '  ' + colorize('gray', 'qwen-powers init .'),
+      '  ' + colorize('gray', 'qwen-powers enable tdd'),
+      '',
+    ];
+    console.log(lines.join('\n'));
+  },
+
+  list() {
+    const skills = fs.readdirSync(SKILLS_DIR).filter(d =>
+      fs.statSync(path.join(SKILLS_DIR, d)).isDirectory()
+    );
+
+    console.log(`\n${colorize('bold', colorize('cyan', '📚 Skills disponibles:'))}\n`);
+
+    skills.forEach((skill, i) => {
+      const skillFile = path.join(SKILLS_DIR, skill, 'SKILL.md');
+      let description = 'Pas de description.';
+      if (fs.existsSync(skillFile)) {
+        const content = fs.readFileSync(skillFile, 'utf-8');
+        const match = content.match(/^#\s*(.+)$/m);
+        const descMatch = content.match(/^[>-]\s+(.+)$/m);
+        description = descMatch ? descMatch[1] : (match ? match[1] : 'Pas de description.');
+      }
+      const enabled = isSkillEnabled(skill);
+      const status = enabled
+        ? colorize('green', '✓ activé')
+        : colorize('gray', '○ désactivé');
+      console.log(`  ${colorize('bold', colorize('yellow', `${i + 1}. ${skill}`))} ${status}`);
+      console.log(`     ${colorize('gray', description)}\n`);
+    });
+
+    console.log(`  ${colorize('gray', `Total: ${skills.length} skills`)}\n`);
+  },
+
+  show(skillName) {
+    if (!skillName) {
+      console.error(colorize('red', '❌ Usage: qwen-powers show <nom-du-skill>'));
+      process.exit(1);
+    }
+    const skillDir = path.join(SKILLS_DIR, skillName);
+    const skillFile = path.join(skillDir, 'SKILL.md');
+
+    if (!fs.existsSync(skillFile)) {
+      console.error(colorize('red', `❌ Skill '${skillName}' introuvable.`));
+      console.log(`   Répertoire: ${skillDir}`);
+      process.exit(1);
+    }
+
+    const content = fs.readFileSync(skillFile, 'utf-8');
+    console.log(`\n${colorize('bold', colorize('cyan', '━'.repeat(60)))}`);
+    console.log(content);
+    console.log(colorize('bold', colorize('cyan', '━'.repeat(60))) + '\n');
+  },
+
+  init(targetDir) {
+    const dest = path.resolve(targetDir || '.');
+    console.log(`\n${colorize('bold', colorize('green', `🚀 Initialisation de Qwen Superpowers dans: ${dest}`))}\n`);
+
+    // Copier le fichier de config racine
+    const configTemplate = path.join(ROOT_DIR, '.qwen-powers.example.json');
+    const configDest = path.join(dest, '.qwen-powers.json');
+
+    if (!fs.existsSync(configDest)) {
+      if (fs.existsSync(configTemplate)) {
+        fs.copyFileSync(configTemplate, configDest);
+        console.log(colorize('green', '  ✓ .qwen-powers.json créé'));
+      } else {
+        const defaultConfig = {
+          version: "1.0.0",
+          enabledSkills: [],
+          workflow: {
+            enforceStages: true,
+            stages: [
+              "brainstorming",
+              "git-worktrees",
+              "writing-plans",
+              "subagent-driven-development",
+              "test-driven-development",
+              "code-review",
+              "finishing-branch"
+            ]
+          },
+          hooks: {
+            preExecute: [],
+            postExecute: []
+          },
+          settings: {
+            tddEnforced: true,
+            codeReviewRequired: true,
+            autoRunTests: true,
+            autoLint: true
+          }
+        };
+        fs.writeFileSync(configDest, JSON.stringify(defaultConfig, null, 2));
+        console.log(colorize('green', '  ✓ .qwen-powers.json créé avec la config par défaut'));
+      }
+    } else {
+      console.log(colorize('yellow', '  ⚠ .qwen-powers.json existe déjà'));
+    }
+
+    // Créer le dossier .qwen-skills symlink ou copie
+    const skillsDest = path.join(dest, '.qwen-skills');
+    if (!fs.existsSync(skillsDest)) {
+      try {
+        // Sur Windows, on copie au lieu de symlink pour éviter les problèmes de permissions
+        copyDirRecursive(SKILLS_DIR, skillsDest);
+        console.log(colorize('green', '  ✓ Skills copiés dans .qwen-skills/'));
+      } catch (e) {
+        console.error(colorize('red', `  ❌ Erreur copie skills: ${e.message}`));
+      }
+    }
+
+    console.log(`\n${colorize('bold', colorize('green', '✅ Initialisation terminée !'))}`);
+    console.log(colorize('gray', '   Exécutez `qwen-powers list` pour voir les skills disponibles.'));
+    console.log(colorize('gray', '   Modifiez .qwen-powers.json pour activer les skills.\n'));
+  },
+
+  enable(skillName) {
+    if (!skillName) {
+      console.error(colorize('red', '❌ Usage: qwen-powers enable <nom-du-skill>'));
+      process.exit(1);
+    }
+    const config = loadConfig();
+    if (!config.enabledSkills.includes(skillName)) {
+      config.enabledSkills.push(skillName);
+      saveConfig(config);
+      console.log(colorize('green', `✓ Skill '${skillName}' activé.`));
+    } else {
+      console.log(colorize('yellow', `⚠ Skill '${skillName}' déjà activé.`));
+    }
+  },
+
+  disable(skillName) {
+    if (!skillName) {
+      console.error(colorize('red', '❌ Usage: qwen-powers disable <nom-du-skill>'));
+      process.exit(1);
+    }
+    const config = loadConfig();
+    config.enabledSkills = config.enabledSkills.filter(s => s !== skillName);
+    saveConfig(config);
+    console.log(colorize('green', `✓ Skill '${skillName}' désactivé.`));
+  },
+
+  workflow() {
+    const stages = [
+      { num: 1, name: 'Brainstorming', desc: 'Questionnement socratique pour affiner l\'idee -> sauvegarde du design doc' },
+      { num: 2, name: 'Git Worktrees', desc: 'Creation d\'un workspace isole -> setup -> verification tests propres' },
+      { num: 3, name: 'Writing Plans', desc: 'Decoupage en taches de 2-5 min avec chemins, snippets et etapes de verification' },
+      { num: 4, name: 'Subagent-Driven Dev', desc: 'Dispatch d\'un sous-agent par tache -> revue 2 etapes -> continue autonome' },
+      { num: 5, name: 'Test-Driven Dev', desc: 'Enforce RED -> GREEN -> REFACTOR -> supprime code ecrit avant tests -> commit si passe' },
+      { num: 6, name: 'Code Review', desc: 'Compare le resultat au plan -> bloque si issues critiques -> rapport par severite' },
+      { num: 7, name: 'Branch Finalization', desc: 'Verifie tous les tests -> presente options merge/PR/garder/supprimer -> cleanup' },
+    ];
+
+    console.log('');
+    console.log(colorize('bold', colorize('cyan', '+---------------------------------------------------------+')));
+    console.log(colorize('bold', colorize('cyan', '|') + '         Workflow en 7 Etapes                     ' + colorize('bold', colorize('cyan', '|'))));
+    console.log(colorize('bold', colorize('cyan', '+---------------------------------------------------------+')));
+    console.log('');
+
+    stages.forEach(s => {
+      console.log('  ' + colorize('bold', colorize('yellow', 'Etape ' + s.num + ':')) + ' ' + colorize('bold', s.name));
+      console.log('     ' + colorize('gray', s.desc));
+      console.log('');
+    });
+  },
+
+  hook(hookName) {
+    if (!hookName) {
+      console.error(colorize('red', '❌ Usage: qwen-powers hook <nom-du-hook>'));
+      process.exit(1);
+    }
+    const hookFile = path.join(ROOT_DIR, 'hooks', `${hookName}.js`);
+    if (!fs.existsSync(hookFile)) {
+      console.error(colorize('red', `❌ Hook '${hookName}' introuvable.`));
+      process.exit(1);
+    }
+    require(hookFile);
+  },
+
+  update() {
+    console.log(colorize('yellow', '⚠ La mise à jour automatique sera implémentée prochainement.'));
+    console.log(colorize('gray', '   Pour l\'instant, mettez à jour via: npm update qwen-superpowers'));
+  },
+
+  create(skillName) {
+    if (!skillName) {
+      console.error(colorize('red', '❌ Usage: qwen-powers create <nom-du-skill>'));
+      process.exit(1);
+    }
+    const slug = skillName.toLowerCase().replace(/\s+/g, '-');
+    const skillDir = path.join(SKILLS_DIR, slug);
+
+    if (fs.existsSync(skillDir)) {
+      console.error(colorize('red', `❌ Le skill '${slug}' existe déjà.`));
+      process.exit(1);
+    }
+
+    fs.mkdirSync(skillDir, { recursive: true });
+
+    const template = `# ${slug.replace(/-/g, ' ').replace(/\b\w/g, c => c.toUpperCase())}
+
+> Décrivez brièvement le but de ce skill.
+
+## Triggers
+- Quand utiliser ce skill ?
+- Quels motifs ou contextes déclenchent ce skill ?
+
+## Instructions
+1. Étape 1
+2. Étape 2
+3. Étape 3
+
+## Règles
+- Règle 1
+- Règle 2
+
+## Sortie attendue
+- Que doit produire l'agent après exécution ?
+
+## Exemple d'utilisation
+\`\`\`
+Exemple concret d'invocation et de résultat attendu.
+\`\`\`
+`;
+
+    fs.writeFileSync(path.join(skillDir, 'SKILL.md'), template);
+    console.log(colorize('green', `✓ Skill '${slug}' créé dans: ${skillDir}`));
+  },
+};
+
+// ─── Helpers ─────────────────────────────────────────────────────
+
+function loadConfig() {
+  if (fs.existsSync(CONFIG_FILE)) {
+    return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf-8'));
+  }
+  return { enabledSkills: [], workflow: { enforceStages: true }, settings: {} };
+}
+
+function saveConfig(config) {
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+
+function isSkillEnabled(skillName) {
+  const config = loadConfig();
+  return config.enabledSkills && config.enabledSkills.includes(skillName);
+}
+
+function copyDirRecursive(src, dest) {
+  if (!fs.existsSync(dest)) {
+    fs.mkdirSync(dest, { recursive: true });
+  }
+  const entries = fs.readdirSync(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      copyDirRecursive(srcPath, destPath);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+// ─── Point d'entrée ──────────────────────────────────────────────
+
+const args = process.argv.slice(2);
+const command = args[0] || 'help';
+
+if (commands[command]) {
+  commands[command](...args.slice(1));
+} else {
+  console.error(colorize('red', `❌ Commande '${command}' inconnue.`));
+  commands.help();
+  process.exit(1);
+}

package/hooks/post-execute.js

@@ -0,0 +1,103 @@
+/**
+ * Hook: post-execute
+ * 
+ * Exécuté APRÈS qu'une tâche ou une commande est terminée.
+ * Utilisé pour vérifier le résultat, nettoyer l'environnement,
+ * et préparer l'étape suivante du workflow.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const ROOT = process.cwd();
+const CONFIG_FILE = path.join(ROOT, '.qwen-powers.json');
+
+function postExecute(context) {
+  const config = loadConfig();
+  const results = {
+    success: true,
+    nextSteps: [],
+    cleanup: [],
+    warnings: []
+  };
+
+  // Vérification post-TDD
+  if (config.settings && config.settings.tddEnforced && context.type === 'code') {
+    const testsPassed = context.testResults && context.testResults.passed;
+    if (!testsPassed) {
+      results.success = false;
+      results.warnings.push({
+        type: 'TDD_VIOLATION',
+        message: 'Les tests ne passent pas. Impossible de continuer ou de commit.'
+      });
+    }
+  }
+
+  // Vérification code review
+  if (config.settings && config.settings.codeReviewRequired) {
+    if (!context.reviewDone) {
+      results.nextSteps.push({
+        action: 'code-review',
+        message: 'Une revue de code est requise avant de continuer. Utilisez le skill `code-review`.'
+      });
+    }
+  }
+
+  // Auto-lint check
+  if (config.settings && config.settings.autoLint) {
+    results.nextSteps.push({
+      action: 'lint',
+      message: 'Vérifiez le linting: `npm run lint` (ou équivalent)'
+    });
+  }
+
+  // Prochaine étape du workflow
+  if (config.workflow && config.workflow.enforceStages) {
+    const currentStage = context.currentStage;
+    const stages = config.workflow.stages;
+    if (currentStage && stages) {
+      const currentIndex = stages.indexOf(currentStage);
+      if (currentIndex >= 0 && currentIndex < stages.length - 1) {
+        const nextStage = stages[currentIndex + 1];
+        results.nextSteps.push({
+          action: `workflow-next`,
+          message: `Prochaine étape du workflow: ${nextStage}`
+        });
+      } else if (currentIndex === stages.length - 1) {
+        results.nextSteps.push({
+          action: 'workflow-complete',
+          message: 'Workflow en 7 étapes terminé ! Prêt pour merge/PR.'
+        });
+      }
+    }
+  }
+
+  // Suggestions de cleanup
+  results.cleanup.push({
+    action: 'remove-debug',
+    message: 'Supprimer les logs/console.log de debug ajoutés pendant le dev'
+  });
+  results.cleanup.push({
+    action: 'format',
+    message: 'Formater le code: `npm run format` (ou équivalent)'
+  });
+
+  return results;
+}
+
+function loadConfig() {
+  if (fs.existsSync(CONFIG_FILE)) {
+    return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf-8'));
+  }
+  return { settings: {}, workflow: {} };
+}
+
+// Export pour utilisation par le système de hooks
+module.exports = { postExecute };
+
+// Si exécuté directement via CLI
+if (require.main === module) {
+  const context = JSON.parse(process.argv[2] || '{}');
+  const result = postExecute(context);
+  console.log(JSON.stringify(result, null, 2));
+}

package/hooks/pre-execute.js

@@ -0,0 +1,106 @@
+/**
+ * Hook: pre-execute
+ * 
+ * Exécuté AVANT qu'une tâche ou une commande ne soit lancée.
+ * Utilisé pour valider l'environnement, sauvegarder l'état, ou blocker
+ * si des conditions ne sont pas remplies.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const ROOT = process.cwd();
+const CONFIG_FILE = path.join(ROOT, '.qwen-powers.json');
+
+function preExecute(context) {
+  const config = loadConfig();
+  const results = {
+    blocked: false,
+    warnings: [],
+    checks: []
+  };
+
+  // Check 1: TDD enforcement
+  if (config.settings && config.settings.tddEnforced && context.type === 'code') {
+    const hasTest = context.files && context.files.some(f => isTestFile(f));
+    if (!hasTest) {
+      results.blocked = true;
+      results.checks.push({
+        name: 'TDD Check',
+        status: '❌ FAIL',
+        message: 'Aucun fichier de test détecté. Le TDD est activé — écrivez le test d\'abord.'
+      });
+    } else {
+      results.checks.push({
+        name: 'TDD Check',
+        status: '✅ PASS',
+        message: 'Fichier de test détecté.'
+      });
+    }
+  }
+
+  // Check 2: Branch isolation
+  if (config.workflow && config.workflow.enforceStages) {
+    const currentBranch = getCurrentBranch();
+    if (currentBranch === 'main' || currentBranch === 'master') {
+      results.blocked = true;
+      results.checks.push({
+        name: 'Branch Check',
+        status: '❌ FAIL',
+        message: `Vous êtes sur la branche '${currentBranch}'. Créez une branche de feature ou utilisez un worktree.`
+      });
+    } else {
+      results.checks.push({
+        name: 'Branch Check',
+        status: '✅ PASS',
+        message: `Branche de travail: ${currentBranch}`
+      });
+    }
+  }
+
+  // Check 3: Tests passing baseline
+  if (config.settings && config.settings.autoRunTests) {
+    results.checks.push({
+      name: 'Baseline Check',
+      status: '⚠️ SKIP',
+      message: 'Vérification des tests existants — assurez-vous que les tests passent avant de commencer.'
+    });
+  }
+
+  return results;
+}
+
+function loadConfig() {
+  if (fs.existsSync(CONFIG_FILE)) {
+    return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf-8'));
+  }
+  return { settings: {}, workflow: {} };
+}
+
+function isTestFile(filePath) {
+  const testPatterns = ['.test.', '.spec.', '__tests__', '/test/', '_test.py', 'test_'];
+  return testPatterns.some(p => filePath.includes(p));
+}
+
+function getCurrentBranch() {
+  try {
+    const { execSync } = require('child_process');
+    return execSync('git branch --show-current', { encoding: 'utf-8' }).trim();
+  } catch {
+    return 'unknown';
+  }
+}
+
+// Export pour utilisation par le système de hooks
+module.exports = { preExecute };
+
+// Si exécuté directement via CLI
+if (require.main === module) {
+  const context = JSON.parse(process.argv[2] || '{}');
+  const result = preExecute(context);
+  console.log(JSON.stringify(result, null, 2));
+
+  if (result.blocked) {
+    process.exit(1);
+  }
+}

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "qwen-superpowers",
+  "version": "1.0.0",
+  "description": "Plugin de super-pouvoirs pour Qwen Code — Transforme l'agent IA en ingenieur logiciel discipline avec workflow structure, TDD, revue de code et developpement par sous-agents.",
+  "main": "cli/index.js",
+  "bin": {
+    "qwen-powers": "./cli/index.js"
+  },
+  "scripts": {
+    "start": "node cli/index.js help",
+    "list": "node cli/index.js list",
+    "install-plugin": "node scripts/install.js",
+    "verify": "node scripts/verify-skills.js",
+    "test": "npm run verify && npm run test:cli",
+    "test:cli": "node cli/index.js help && node cli/index.js list && node cli/index.js workflow",
+    "prepublishOnly": "npm test",
+    "preversion": "npm test",
+    "version": "node scripts/version.js && git add CHANGELOG.md",
+    "postversion": "echo \"Nouvelle version: $(node -p \"require('./package.json').version\")\""
+  },
+  "keywords": [
+    "qwen",
+    "qwen-code",
+    "cli",
+    "skills",
+    "plugin",
+    "tdd",
+    "code-review",
+    "workflow",
+    "ai-agent",
+    "superpowers",
+    "agent",
+    "coding-assistant"
+  ],
+  "author": "",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/stelio-fondation/qwen-superpowers"
+  },
+  "bugs": {
+    "url": "https://github.com/stelio-fondation/qwen-superpowers/issues"
+  },
+  "homepage": "https://github.com/stelio-fondation/qwen-superpowers#readme",
+  "files": [
+    "cli/",
+    "skills/",
+    "hooks/",
+    "scripts/",
+    "AGENTS.md",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE",
+    "package.json"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "os": [
+    "win32",
+    "darwin",
+    "linux"
+  ],
+  "preferGlobal": true
+}

package/scripts/install.js

@@ -0,0 +1,71 @@
+/**
+ * Script d'installation pour qwen-superpowers
+ * Copie les fichiers nécessaires dans le projet cible.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const ROOT = path.join(__dirname, '..');
+
+function install(targetDir) {
+  const dest = path.resolve(targetDir || process.cwd());
+  console.log(`\n🚀 Installation de Qwen Superpowers dans: ${dest}\n`);
+
+  // 1. Copier AGENTS.md
+  const agentsSrc = path.join(ROOT, 'AGENTS.md');
+  const agentsDest = path.join(dest, 'AGENTS.md');
+  if (!fs.existsSync(agentsDest)) {
+    fs.copyFileSync(agentsSrc, agentsDest);
+    console.log('  ✓ AGENTS.md copié');
+  } else {
+    console.log('  ⚠ AGENTS.md existe déjà');
+  }
+
+  // 2. Copier .qwen-powers.json
+  const configSrc = path.join(ROOT, '.qwen-powers.example.json');
+  const configDest = path.join(dest, '.qwen-powers.json');
+  if (!fs.existsSync(configDest)) {
+    fs.copyFileSync(configSrc, configDest);
+    console.log('  ✓ .qwen-powers.json créé');
+  } else {
+    console.log('  ⚠ .qwen-powers.json existe déjà');
+  }
+
+  // 3. Copier les skills
+  const skillsSrc = path.join(ROOT, 'skills');
+  const skillsDest = path.join(dest, '.qwen-skills');
+  if (!fs.existsSync(skillsDest)) {
+    copyDirRecursive(skillsSrc, skillsDest);
+    console.log('  ✓ Skills copiés dans .qwen-skills/');
+  } else {
+    console.log('  ⚠ .qwen-skills/ existe déjà');
+  }
+
+  console.log('\n✅ Installation terminée !');
+  console.log('   Modifiez .qwen-powers.json pour configurer les skills.\n');
+}
+
+function copyDirRecursive(src, dest) {
+  if (!fs.existsSync(dest)) {
+    fs.mkdirSync(dest, { recursive: true });
+  }
+  const entries = fs.readdirSync(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      copyDirRecursive(srcPath, destPath);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+// Exécuter si appelé directement
+if (require.main === module) {
+  const target = process.argv[2] || '.';
+  install(target);
+}
+
+module.exports = { install };