create-byan-agent 2.6.1 → 2.7.0

package/bin/create-byan-agent-backup.js

@@ -0,0 +1,220 @@
+#!/usr/bin/env node
+
+const fs = require('fs-extra');
+const path = require('path');
+const { program } = require('commander');
+const inquirer = require('inquirer');
+const chalk = require('chalk');
+const ora = require('ora');
+const yaml = require('js-yaml');
+
+const BYAN_VERSION = '1.0.0';
+
+// ASCII Art Banner
+const banner = `
+${chalk.blue('╔════════════════════════════════════════════════════════════╗')}
+${chalk.blue('║')}                                                            ${chalk.blue('║')}
+${chalk.blue('║')}   ${chalk.bold('🏗️  BYAN INSTALLER v' + BYAN_VERSION)}                        ${chalk.blue('║')}
+${chalk.blue('║')}   ${chalk.gray('Builder of YAN - Agent Creator')}                          ${chalk.blue('║')}
+${chalk.blue('║')}                                                            ${chalk.blue('║')}
+${chalk.blue('║')}   ${chalk.gray('Methodology: Merise Agile + TDD + 64 Mantras')}           ${chalk.blue('║')}
+${chalk.blue('║')}                                                            ${chalk.blue('║')}
+${chalk.blue('╚════════════════════════════════════════════════════════════╝')}
+`;
+
+// Main installer
+async function install() {
+  console.clear();
+  console.log(banner);
+  
+  const projectRoot = process.cwd();
+  
+  // Step 1: Detect project type
+  const spinner = ora('Detecting project type...').start();
+  
+  const isGitRepo = await fs.pathExists(path.join(projectRoot, '.git'));
+  const hasPackageJson = await fs.pathExists(path.join(projectRoot, 'package.json'));
+  const hasPyProject = await fs.pathExists(path.join(projectRoot, 'pyproject.toml'));
+  
+  if (!isGitRepo && !hasPackageJson && !hasPyProject) {
+    spinner.warn('Not in a recognized project directory');
+    
+    const { continueAnyway } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'continueAnyway',
+        message: 'BYAN works best in a project with version control. Continue anyway?',
+        default: false
+      }
+    ]);
+    
+    if (!continueAnyway) {
+      console.log(chalk.yellow('Installation cancelled.'));
+      process.exit(0);
+    }
+  } else {
+    spinner.succeed('Project detected');
+  }
+  
+  // Step 2: Platform selection
+  const { platform } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'platform',
+      message: 'Select platform to install for:',
+      choices: [
+        { name: 'GitHub Copilot CLI', value: 'copilot' },
+        { name: 'VSCode', value: 'vscode' },
+        { name: 'Claude Code', value: 'claude' },
+        { name: 'Codex', value: 'codex' },
+        { name: 'All platforms', value: 'all' }
+      ]
+    }
+  ]);
+  
+  // Step 3: User configuration
+  const config = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'userName',
+      message: 'Your name:',
+      default: 'Developer'
+    },
+    {
+      type: 'list',
+      name: 'language',
+      message: 'Communication language:',
+      choices: ['Francais', 'English'],
+      default: 'English'
+    }
+  ]);
+  
+  // Step 4: Create directory structure
+  const installSpinner = ora('Creating directory structure...').start();
+  
+  const bmadDir = path.join(projectRoot, '_bmad');
+  const bmbDir = path.join(bmadDir, 'bmb');
+  
+  await fs.ensureDir(path.join(bmadDir, 'bmb', 'agents'));
+  await fs.ensureDir(path.join(bmadDir, 'bmb', 'workflows', 'byan', 'steps'));
+  await fs.ensureDir(path.join(bmadDir, 'bmb', 'workflows', 'byan', 'templates'));
+  await fs.ensureDir(path.join(bmadDir, 'bmb', 'workflows', 'byan', 'data'));
+  await fs.ensureDir(path.join(bmadDir, 'core'));
+  await fs.ensureDir(path.join(bmadDir, '_config'));
+  await fs.ensureDir(path.join(bmadDir, '_memory'));
+  await fs.ensureDir(path.join(bmadDir, '_output'));
+  
+  installSpinner.succeed('Directory structure created');
+  
+  // Step 5: Copy BYAN files
+  const copySpinner = ora('Installing BYAN files...').start();
+  
+  // In production, these would be copied from the package
+  // For now, we'll create minimal config
+  
+  const configContent = {
+    bmb_creations_output_folder: "{project-root}/_bmad-output/bmb-creations",
+    user_name: config.userName,
+    communication_language: config.language,
+    document_output_language: config.language,
+    output_folder: "{project-root}/_bmad-output",
+    platform: platform
+  };
+  
+  const configPath = path.join(bmbDir, 'config.yaml');
+  await fs.writeFile(configPath, yaml.dump(configContent), 'utf8');
+  
+  copySpinner.succeed('BYAN files installed');
+  
+  // Step 6: Create shortcuts
+  const shortcutSpinner = ora('Creating shortcuts...').start();
+  
+  // Create package.json scripts if it exists
+  if (hasPackageJson) {
+    const pkgPath = path.join(projectRoot, 'package.json');
+    const pkg = await fs.readJson(pkgPath);
+    
+    if (!pkg.scripts) pkg.scripts = {};
+    
+    if (!pkg.scripts.byan) {
+      pkg.scripts.byan = 'echo "BYAN agent installed. Activate in your AI platform."';
+      await fs.writeJson(pkgPath, pkg, { spaces: 2 });
+      shortcutSpinner.succeed('NPM script added');
+    } else {
+      shortcutSpinner.info('NPM script already exists');
+    }
+  } else {
+    shortcutSpinner.succeed('Shortcuts created');
+  }
+  
+  // Step 7: Verification
+  const verifySpinner = ora('Verifying installation...').start();
+  
+  const checks = [
+    await fs.pathExists(path.join(bmbDir, 'agents')),
+    await fs.pathExists(path.join(bmbDir, 'workflows', 'byan')),
+    await fs.pathExists(configPath)
+  ];
+  
+  const passed = checks.filter(Boolean).length;
+  
+  if (passed === checks.length) {
+    verifySpinner.succeed(`Verification: ${passed}/${checks.length} checks passed`);
+  } else {
+    verifySpinner.warn(`Verification: ${passed}/${checks.length} checks passed`);
+  }
+  
+  // Success message
+  console.log('');
+  console.log(chalk.green('╔════════════════════════════════════════════════════════════╗'));
+  console.log(chalk.green('║                                                            ║'));
+  console.log(chalk.green('║   ✅ BYAN INSTALLATION COMPLETE!                           ║'));
+  console.log(chalk.green('║                                                            ║'));
+  console.log(chalk.green('╚════════════════════════════════════════════════════════════╝'));
+  console.log('');
+  
+  console.log(chalk.bold('Installation Summary:'));
+  console.log(`  • Platform: ${chalk.cyan(platform)}`);
+  console.log(`  • Installation Directory: ${chalk.cyan(bmbDir)}`);
+  console.log(`  • Configuration: ${chalk.cyan(configPath)}`);
+  console.log(`  • User: ${chalk.cyan(config.userName)}`);
+  console.log(`  • Language: ${chalk.cyan(config.language)}`);
+  console.log('');
+  
+  console.log(chalk.bold('Next Steps:'));
+  console.log('');
+  console.log(chalk.yellow('1. Activate BYAN:'));
+  
+  if (platform === 'copilot') {
+    console.log(`   ${chalk.blue('gh copilot suggest "activate byan agent"')}`);
+  } else if (platform === 'vscode') {
+    console.log('   Open VSCode Command Palette (Ctrl+Shift+P)');
+    console.log('   Type: "Activate BYAN Agent"');
+  } else if (platform === 'claude') {
+    console.log(`   ${chalk.blue('claude chat --agent byan')}`);
+  }
+  
+  console.log('');
+  console.log(chalk.yellow('2. Create your first agent:'));
+  console.log('   [INT] Start Intelligent Interview (30-45 min)');
+  console.log('   [QC] Quick Create (10 min)');
+  console.log('');
+  
+  console.log(chalk.yellow('3. Explore documentation:'));
+  console.log(`   • Configuration: ${chalk.cyan(configPath)}`);
+  console.log(`   • Workflows: ${chalk.cyan(path.join(bmbDir, 'workflows', 'byan'))}`);
+  console.log('');
+  
+  console.log(chalk.gray('Need help? Type \'/bmad-help\' when BYAN is active'));
+  console.log('');
+  console.log(chalk.blue('Happy agent building! 🏗️'));
+}
+
+// CLI Program
+program
+  .name('create-byan-agent')
+  .description('Install BYAN - Builder of YAN agent creator')
+  .version(BYAN_VERSION)
+  .action(install);
+
+program.parse(process.argv);

package/{install/bin → bin}/create-byan-agent-v2.js

@@ -436,7 +436,8 @@ async function install() {
         { name: 'carmack', label: 'Carmack - Token Optimizer [worker]', checked: false }
       ],
       'Custom Agents': [
-        { name: 'jimmy', label: 'Jimmy - Technical Documentation Specialist (Runbooks, Infra, Deploy, Web — Outline Wiki) [worker]', checked: false }
+        { name: 'jimmy', label: 'Jimmy - Technical Documentation Specialist (Runbooks, Infra, Deploy, Web — Outline Wiki) [worker]', checked: false },
+        { name: 'mike', label: 'Mike - Project Manager Specialist (Projects, Tasks, Sprints, Milestones — Leantime) [worker]', checked: false }
       ]
     };
 
@@ -1345,7 +1346,7 @@ async function install() {
     output_folder: "{project-root}/_byan-output",
     platform: isManual ? manualSelection.platforms.join(',') : platform,
     install_mode: installMode,
-    byan_version: v2Installed ? '2.0.0-alpha.1' : '1.0.0'
+    byan_version: BYAN_VERSION
   };
   
   // Add installed agents list for MANUAL mode
@@ -1358,6 +1359,132 @@ async function install() {
   
   configSpinner.succeed('Configuration generated');
   
+  // Step 8.5: Soul & Voice Setup
+  console.log('');
+  console.log(chalk.blue('--- Soul & Voice System ---'));
+  console.log(chalk.gray('BYAN agents can carry a soul (values, personality, guardrails)'));
+  console.log(chalk.gray('and a voice/tao (verbal signatures, tone, speech patterns).'));
+  console.log('');
+  
+  const { soulMode } = await inquirer.prompt([{
+    type: 'list',
+    name: 'soulMode',
+    message: 'Soul setup mode:',
+    choices: [
+      { name: 'CREATOR — Use Yan\'s soul as foundation (recommended for first-timers)', value: 'creator' },
+      { name: 'BLANK — Start with empty templates to fill yourself', value: 'blank' },
+      { name: 'IMPORT — Import existing soul files from a path', value: 'import' },
+      { name: 'SKIP — No soul setup (can be added later)', value: 'skip' }
+    ],
+    default: 'creator'
+  }]);
+  
+  if (soulMode !== 'skip') {
+    const soulSpinner = ora('Setting up Soul & Voice system...').start();
+    const soulDir = byanDir; // _byan/ root for soul files
+    
+    try {
+      if (soulMode === 'creator') {
+        // Copy Yan's creator-soul as foundation + blank personal soul/tao
+        const creatorSoulSrc = path.join(templateDir, '_byan', 'creator-soul.md');
+        const soulRefSrc = path.join(templateDir, '_byan', 'byan-soul-reference.md');
+        const taoRefSrc = path.join(templateDir, '_byan', 'byan-tao-reference.md');
+        const memoryRefSrc = path.join(templateDir, '_byan', 'soul-memory-reference.md');
+        const soulTemplateSrc = path.join(templateDir, '_byan', 'soul-template.md');
+        const memoryTemplateSrc = path.join(templateDir, '_byan', 'soul-memory-template.md');
+        
+        // Copy creator-soul as-is (Yan's soul = the original)
+        if (await fs.pathExists(creatorSoulSrc)) {
+          await fs.copy(creatorSoulSrc, path.join(soulDir, 'creator-soul.md'));
+        }
+        // Copy references for inspiration
+        if (await fs.pathExists(soulRefSrc)) {
+          await fs.copy(soulRefSrc, path.join(soulDir, 'byan-soul-reference.md'));
+        }
+        if (await fs.pathExists(taoRefSrc)) {
+          await fs.copy(taoRefSrc, path.join(soulDir, 'byan-tao-reference.md'));
+        }
+        if (await fs.pathExists(memoryRefSrc)) {
+          await fs.copy(memoryRefSrc, path.join(soulDir, 'soul-memory-reference.md'));
+        }
+        // Create user's own soul from template (to be filled)
+        if (await fs.pathExists(soulTemplateSrc)) {
+          await fs.copy(soulTemplateSrc, path.join(soulDir, 'soul.md'));
+        }
+        if (await fs.pathExists(memoryTemplateSrc)) {
+          await fs.copy(memoryTemplateSrc, path.join(soulDir, 'soul-memory.md'));
+        }
+        
+        soulSpinner.succeed('Soul system installed (Creator mode — Yan\'s soul as foundation)');
+        console.log(chalk.green('  + creator-soul.md — Yan\'s original soul (read-only reference)'));
+        console.log(chalk.green('  + byan-soul-reference.md — BYAN\'s soul (example)'));
+        console.log(chalk.green('  + byan-tao-reference.md — BYAN\'s voice (example)'));
+        console.log(chalk.green('  + soul.md — YOUR soul (fill with your values)'));
+        console.log(chalk.green('  + soul-memory.md — Living journal (grows with usage)'));
+        console.log(chalk.cyan('  Tip: Use @byan with the Forge workflow to build your soul interactively'));
+        
+      } else if (soulMode === 'blank') {
+        // Copy blank templates only
+        const creatorTemplateSrc = path.join(templateDir, '_byan', 'creator-soul-template.md');
+        const soulTemplateSrc = path.join(templateDir, '_byan', 'soul-template.md');
+        const memoryTemplateSrc = path.join(templateDir, '_byan', 'soul-memory-template.md');
+        
+        if (await fs.pathExists(creatorTemplateSrc)) {
+          await fs.copy(creatorTemplateSrc, path.join(soulDir, 'creator-soul.md'));
+        }
+        if (await fs.pathExists(soulTemplateSrc)) {
+          await fs.copy(soulTemplateSrc, path.join(soulDir, 'soul.md'));
+        }
+        if (await fs.pathExists(memoryTemplateSrc)) {
+          await fs.copy(memoryTemplateSrc, path.join(soulDir, 'soul-memory.md'));
+        }
+        
+        soulSpinner.succeed('Soul system installed (Blank mode — empty templates)');
+        console.log(chalk.green('  + creator-soul.md — Template to fill with YOUR values'));
+        console.log(chalk.green('  + soul.md — Template for BYAN\'s personality'));
+        console.log(chalk.green('  + soul-memory.md — Living journal (empty)'));
+        console.log(chalk.cyan('  Tip: Use @byan with the Forge workflow to build your soul interactively'));
+        
+      } else if (soulMode === 'import') {
+        const { importPath } = await inquirer.prompt([{
+          type: 'input',
+          name: 'importPath',
+          message: 'Path to soul directory (containing creator-soul.md, soul.md, etc.):',
+          validate: (input) => {
+            if (!input) return 'Please provide a path';
+            if (!fs.existsSync(input)) return `Path not found: ${input}`;
+            return true;
+          }
+        }]);
+        
+        const soulFiles = ['creator-soul.md', 'soul.md', 'soul-memory.md', 'tao.md'];
+        let imported = 0;
+        
+        for (const file of soulFiles) {
+          const src = path.join(importPath, file);
+          if (await fs.pathExists(src)) {
+            await fs.copy(src, path.join(soulDir, file));
+            imported++;
+            console.log(chalk.green(`  + ${file} imported`));
+          }
+        }
+        
+        soulSpinner.succeed(`Soul system imported (${imported} files from ${importPath})`);
+      }
+      
+      // Add soul_mode to config
+      const existingConfig = yaml.load(await fs.readFile(configPath, 'utf8'));
+      existingConfig.soul_mode = soulMode;
+      await fs.writeFile(configPath, yaml.dump(existingConfig), 'utf8');
+      
+    } catch (soulError) {
+      soulSpinner.warn(`Soul setup had issues: ${soulError.message}`);
+      console.log(chalk.yellow('  Soul files can be added manually later'));
+    }
+    
+    console.log('');
+  }
+  
   // Step 9: Create package.json script
   const shortcutSpinner = ora('Creating shortcuts...').start();
   
@@ -1387,6 +1514,12 @@ async function install() {
     { name: 'Config', path: configPath }
   ];
   
+  // Soul system checks
+  if (soulMode && soulMode !== 'skip') {
+    checks.push({ name: 'Soul file', path: path.join(byanDir, 'soul.md') });
+    checks.push({ name: 'Soul memory', path: path.join(byanDir, 'soul-memory.md') });
+  }
+  
   // Platform-specific checks based on installation mode
   if (isManual) {
     if (manualPlatformList.includes('copilot')) {
@@ -1465,6 +1598,7 @@ async function install() {
   console.log(`  • User: ${chalk.cyan(config.userName)}`);
   console.log(`  • Language: ${chalk.cyan(config.language)}`);
   console.log(`  • Turbo Whisper: ${chalk.cyan(turboWhisperInstalled ? `Installed (${turboWhisperMode} mode)` : 'Not installed')}`);
+  console.log(`  • Soul System: ${chalk.cyan(soulMode === 'skip' ? 'Not installed' : `${soulMode} mode`)}`);
   console.log(`  • Model Selector: ${chalk.cyan('Integrated (Auto cost optimization)')}`);
   
   if (isManual && manualSelection) {
@@ -1553,4 +1687,230 @@ program
   .version(BYAN_VERSION)
   .action(install);
 
+// Update Command
+program
+  .command('update')
+  .description('Mettre a jour BYAN vers la derniere version npm')
+  .option('--dry-run', 'Analyser sans appliquer les changements')
+  .option('--force', 'Forcer la mise a jour meme si deja a jour')
+  .action(async (options) => {
+    const installPath = process.cwd();
+    
+    // Import update modules
+    const Analyzer = require('../../update-byan-agent/lib/analyzer');
+    const Backup = require('../../update-byan-agent/lib/backup');
+    const CustomizationDetector = require('../../update-byan-agent/lib/customization-detector');
+    
+    try {
+      // Step 1: Check version
+      const spinner = ora('Verification version...').start();
+      const analyzer = new Analyzer(installPath);
+      const versionInfo = await analyzer.checkVersion();
+      spinner.succeed(`Version actuelle: ${versionInfo.current}, npm: ${versionInfo.latest}`);
+      
+      if (versionInfo.upToDate && !options.force) {
+        console.log(chalk.green('\nBYAN est deja a jour!'));
+        console.log(chalk.gray(`  Version actuelle: ${versionInfo.current}`));
+        return;
+      }
+      
+      if (options.dryRun) {
+        console.log(chalk.cyan('\nMode dry-run: Aucune modification appliquee'));
+        console.log(chalk.gray(`  Mise a jour disponible: ${versionInfo.current} -> ${versionInfo.latest}`));
+        return;
+      }
+      
+      // Step 2: Confirm update
+      const { confirmUpdate } = await inquirer.prompt([{
+        type: 'confirm',
+        name: 'confirmUpdate',
+        message: `Mettre a jour BYAN ${versionInfo.current} -> ${versionInfo.latest}?`,
+        default: true
+      }]);
+      
+      if (!confirmUpdate) {
+        console.log(chalk.yellow('Mise a jour annulee'));
+        return;
+      }
+      
+      // Step 3: Detect customizations
+      const detectorSpinner = ora('Detection des personnalisations...').start();
+      const detector = new CustomizationDetector(installPath);
+      const customizations = await detector.detectCustomizations();
+      detectorSpinner.succeed(`${customizations.length} fichiers a preserver detectes`);
+      
+      // Step 4: Create backup
+      const backupSpinner = ora('Creation backup...').start();
+      const backup = new Backup(installPath);
+      const backupPath = await backup.create();
+      backupSpinner.succeed(`Backup cree: ${path.basename(backupPath)}`);
+      
+      // Step 5: Preserve customizations
+      const preserveSpinner = ora('Sauvegarde des personnalisations...').start();
+      const tempDir = path.join(installPath, '.byan-update-temp');
+      if (fs.existsSync(tempDir)) {
+        await fs.remove(tempDir);
+      }
+      await fs.ensureDir(tempDir);
+      
+      for (const custom of customizations) {
+        if (await fs.pathExists(custom.path)) {
+          const relativePath = path.relative(installPath, custom.path);
+          const tempPath = path.join(tempDir, relativePath);
+          const tempParent = path.dirname(tempPath);
+          
+          await fs.ensureDir(tempParent);
+          await fs.copy(custom.path, tempPath);
+        }
+      }
+      preserveSpinner.succeed('Personnalisations sauvegardees');
+      
+      // Step 6: Download and install latest version
+      const updateSpinner = ora('Telechargement derniere version...').start();
+      try {
+        // Remove current _byan directory
+        const byanDir = path.join(installPath, '_byan');
+        if (await fs.pathExists(byanDir)) {
+          await fs.remove(byanDir);
+        }
+        
+        // Run npm install to get latest create-byan-agent
+        execSync('npm install --no-save create-byan-agent@latest', {
+          cwd: installPath,
+          stdio: 'pipe'
+        });
+        
+        // Copy _byan from node_modules to project root
+        const nodeModulesByan = path.join(installPath, 'node_modules', 'create-byan-agent', '_byan');
+        if (await fs.pathExists(nodeModulesByan)) {
+          await fs.copy(nodeModulesByan, byanDir);
+        } else {
+          throw new Error('_byan directory not found in npm package');
+        }
+        
+        updateSpinner.succeed('Derniere version installee');
+      } catch (error) {
+        updateSpinner.fail('Erreur installation');
+        
+        // Rollback
+        const rollbackSpinner = ora('Restauration backup...').start();
+        await backup.restore(backupPath);
+        rollbackSpinner.succeed('Backup restaure');
+        
+        throw error;
+      }
+      
+      // Step 7: Restore customizations
+      const restoreSpinner = ora('Restauration personnalisations...').start();
+      for (const custom of customizations) {
+        const relativePath = path.relative(installPath, custom.path);
+        const tempPath = path.join(tempDir, relativePath);
+        
+        if (await fs.pathExists(tempPath)) {
+          const targetParent = path.dirname(custom.path);
+          await fs.ensureDir(targetParent);
+          await fs.copy(tempPath, custom.path);
+        }
+      }
+      restoreSpinner.succeed('Personnalisations restaurees');
+      
+      // Cleanup temp directory
+      if (await fs.pathExists(tempDir)) {
+        await fs.remove(tempDir);
+      }
+      
+      // Update version in config.yaml
+      const configPath = path.join(installPath, '_byan', 'bmb', 'config.yaml');
+      if (await fs.pathExists(configPath)) {
+        const configContent = await fs.readFile(configPath, 'utf8');
+        const config = yaml.load(configContent);
+        config.byan_version = versionInfo.latest;
+        await fs.writeFile(configPath, yaml.dump(config), 'utf8');
+      }
+      
+      console.log('');
+      console.log(chalk.green.bold('Mise a jour terminee avec succes!'));
+      console.log(chalk.gray(`  ${versionInfo.current} -> ${versionInfo.latest}`));
+      console.log('');
+      console.log(chalk.cyan('Fichiers preserves:'));
+      customizations.forEach(c => {
+        console.log(chalk.gray(`  ✓ ${path.relative(installPath, c.path)}`));
+      });
+      console.log('');
+      
+    } catch (error) {
+      console.error('');
+      console.error(chalk.red.bold('Erreur lors de la mise a jour:'));
+      console.error(chalk.red(`  ${error.message}`));
+      console.error('');
+      console.error(chalk.yellow('Le backup est disponible dans _byan.backup/'));
+      console.error(chalk.gray('Restaurer avec: npx create-byan-agent restore'));
+      process.exit(1);
+    }
+  });
+
+// Restore Command
+program
+  .command('restore')
+  .description('Restaurer BYAN depuis backup')
+  .option('-p, --path <path>', 'Chemin du backup (dernier par defaut)')
+  .action(async (options) => {
+    const Backup = require('../../update-byan-agent/lib/backup');
+    const spinner = ora('Restauration backup...').start();
+    
+    try {
+      const installPath = process.cwd();
+      const backup = new Backup(installPath);
+      
+      await backup.restore(options.path);
+      
+      spinner.succeed('Backup restaure avec succes');
+      console.log(chalk.green('\nBYAN restaure depuis backup'));
+      
+    } catch (error) {
+      spinner.fail('Erreur restauration backup');
+      console.error(chalk.red(`  ${error.message}`));
+      process.exit(1);
+    }
+  });
+
+// Check Version Command
+program
+  .command('check')
+  .description('Verifier version actuelle vs derniere version npm')
+  .action(async () => {
+    const Analyzer = require('../../update-byan-agent/lib/analyzer');
+    const spinner = ora('Verification version BYAN...').start();
+    
+    try {
+      const installPath = process.cwd();
+      const analyzer = new Analyzer(installPath);
+      
+      const versionInfo = await analyzer.checkVersion();
+      
+      spinner.succeed('Verification terminee');
+      
+      console.log('');
+      console.log(chalk.bold('Informations de version:'));
+      console.log(chalk.gray('  Version actuelle: ') + chalk.cyan(versionInfo.current));
+      console.log(chalk.gray('  Version npm:      ') + chalk.cyan(versionInfo.latest));
+      console.log('');
+      
+      if (versionInfo.upToDate) {
+        console.log(chalk.green('  ✓ BYAN est a jour!'));
+      } else if (versionInfo.needsUpdate) {
+        console.log(chalk.yellow('  → Une mise a jour est disponible'));
+        console.log(chalk.gray('  Executer: npx create-byan-agent update'));
+      } else if (versionInfo.ahead) {
+        console.log(chalk.blue('  → Version dev en avance sur npm'));
+      }
+      console.log('');
+      
+    } catch (error) {
+      spinner.fail('Erreur verification version');
+      console.error(chalk.red(`  ${error.message}`));
+      process.exit(1);
+    }
+  });
+
 program.parse(process.argv);