create-byan-agent 2.1.1 → 2.2.2

package/install/bin/create-byan-agent-v2.js

@@ -2,23 +2,31 @@
 
 const fs = require('fs-extra');
 const path = require('path');
+const os = require('os');
+const { execSync } = require('child_process');
 const { program } = require('commander');
 const inquirer = require('inquirer');
 const chalk = require('chalk');
 const ora = require('ora');
 const yaml = require('js-yaml');
 
-const BYAN_VERSION = '2.0.0-alpha.1';
+// Phase 2 modules
+const { getDomainQuestions, buildPhase2Prompt } = require('../lib/domain-questions');
+const { generateProjectAgentsDoc } = require('../lib/project-agents-generator');
+const { launchPhase2Chat, generateDefaultConfig } = require('../lib/phase2-chat');
+
+const BYAN_VERSION = '2.3.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.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('Architecture: 4 Pilliers + v2.0 Runtime')}              ${chalk.blue('║')}
+${chalk.blue('║')}   ${chalk.gray('Architecture: _byan/ + Model Selector')}                ${chalk.blue('║')}
 ${chalk.blue('║')}   ${chalk.gray('Methodology: Merise Agile + TDD + 64 Mantras')}           ${chalk.blue('║')}
+${chalk.blue('║')}   ${chalk.gray('Intelligence: Auto GPU Detection + Multi-Platform')}       ${chalk.blue('║')}
 ${chalk.blue('║')}                                                            ${chalk.blue('║')}
 ${chalk.blue('╚════════════════════════════════════════════════════════════╝')}
 `;
@@ -87,6 +95,95 @@ async function copyV2Runtime(templateDir, projectRoot, spinner) {
   return copiedCount;
 }
 
+// Detect installed platforms (Yanstaller logic)
+// Detects SYSTEM binaries, not project folders (.codex, .github/agents are created by yanstaller)
+async function detectPlatforms() {
+  const platforms = {
+    copilot: false,
+    codex: false,
+    claude: false
+  };
+  
+  // GitHub Copilot CLI detection (binary + config)
+  try {
+    const result = execSync('which copilot 2>/dev/null', { encoding: 'utf8' }).trim();
+    if (result) {
+      platforms.copilot = true;
+    }
+  } catch (e) {
+    // Fallback: check config directory (means it was installed)
+    const copilotPaths = [
+      path.join(os.homedir(), '.config', 'github-copilot'),
+      path.join(os.homedir(), '.config', 'copilot')
+    ];
+    for (const p of copilotPaths) {
+      if (fs.existsSync(p)) {
+        platforms.copilot = true;
+        break;
+      }
+    }
+  }
+  
+  // Codex detection (binary + config, NOT project .codex/ folder)
+  try {
+    const result = execSync('which codex 2>/dev/null', { encoding: 'utf8' }).trim();
+    if (result) {
+      platforms.codex = true;
+    }
+  } catch (e) {
+    // Fallback: check config directory
+    const codexPaths = [
+      path.join(os.homedir(), '.config', 'codex'),
+      path.join(os.homedir(), '.codex')
+    ];
+    for (const p of codexPaths) {
+      if (fs.existsSync(p)) {
+        platforms.codex = true;
+        break;
+      }
+    }
+  }
+  
+  // Claude Code detection (binary + config)
+  try {
+    const result = execSync('which claude 2>/dev/null', { encoding: 'utf8' }).trim();
+    if (result) {
+      platforms.claude = true;
+    }
+  } catch (e) {
+    // Fallback: check config directory
+    const claudePaths = [
+      path.join(os.homedir(), '.config', 'claude'),
+      path.join(os.homedir(), '.claude')
+    ];
+    for (const p of claudePaths) {
+      if (fs.existsSync(p)) {
+        platforms.claude = true;
+        break;
+      }
+    }
+  }
+  
+  return platforms;
+}
+
+// Calculate installation complexity (Model Selector)
+function calculateInstallComplexity() {
+  const weights = {
+    task_type: { install: 10 },
+    context_size: { small: 5 },
+    reasoning_depth: { shallow: 0 },
+    quality_requirement: { fast: 0 }
+  };
+  
+  const score = weights.task_type.install + 
+                weights.context_size.small + 
+                weights.reasoning_depth.shallow + 
+                weights.quality_requirement.fast;
+  
+  return { score, recommended: score <= 30 ? 'gpt-5-mini (FREE)' : 'claude-haiku-4.5' };
+}
+
 // Merge package.json with v2.0 dependencies
 async function mergePackageJson(templateDir, projectRoot, spinner) {
   const templatePkgPath = path.join(templateDir, 'package.json');
@@ -209,19 +306,431 @@ async function install() {
     detectSpinner.succeed('BYAN v1.0 detected (Platform only)');
   }
   
-  // Step 3: Platform selection
+  // Step 2.5: Auto-detect installed platforms (Yanstaller logic)
+  console.log('');
+  const platformSpinner = ora('Detecting installed AI platforms...').start();
+  const detectedPlatforms = await detectPlatforms();
+  platformSpinner.succeed('Platform detection complete');
+  
+  console.log(chalk.cyan('\n📦 Installed Platforms:'));
+  console.log(`  GitHub Copilot CLI: ${detectedPlatforms.copilot ? chalk.green('✓ Detected') : chalk.gray('✗ Not found')}`);
+  console.log(`  OpenAI Codex:       ${detectedPlatforms.codex ? chalk.green('✓ Detected') : chalk.gray('✗ Not found')}`);
+  console.log(`  Claude Code:        ${detectedPlatforms.claude ? chalk.green('✓ Detected') : chalk.gray('✗ Not found')}`);
+  console.log('');
+  
+  // Calculate recommended model for installation
+  const complexity = calculateInstallComplexity();
+  console.log(chalk.cyan('🧠 Model Selector (Complexity Analysis):'));
+  console.log(`  Installation Score: ${chalk.yellow(complexity.score)} (simple task)`);
+  console.log(`  Recommended Model:  ${chalk.green(complexity.recommended)}`);
+  console.log(chalk.gray('  → Optimized for cost efficiency during installation'));
+  console.log('');
+  
+  // Step 2.8: Installation mode selection
+  const { installMode } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'installMode',
+      message: 'Choose installation mode:',
+      choices: [
+        { name: '🚀 AUTO - Quick install with smart defaults (Recommended)', value: 'auto' },
+        { name: '🎯 CUSTOM - Guided interview with personalized recommendations', value: 'custom' }
+      ],
+      default: 'auto'
+    }
+  ]);
+
+  let interviewResults = null;
+  let interviewAnswers = null;
+
+  // Step 2.9: Intelligent Interview (if CUSTOM mode) - Delegate to Yanstaller Agent
+  if (installMode === 'custom') {
+    console.log('');
+    console.log(chalk.blue('╔════════════════════════════════════════════════════════════╗'));
+    console.log(chalk.blue('║                                                            ║'));
+    console.log(chalk.blue('║   🎯 YANSTALLER - Intelligent Interview                    ║'));
+    console.log(chalk.blue('║   Powered by bmad-agent-yanstaller                         ║'));
+    console.log(chalk.blue('║                                                            ║'));
+    console.log(chalk.blue('╚════════════════════════════════════════════════════════════╝'));
+    console.log('');
+    
+    // Gather user context via inquirer FIRST (fast, local, no tokens)
+    interviewAnswers = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'projectType',
+        message: '1. Type de projet?',
+        choices: [
+          { name: 'Nouveau (from scratch)', value: 'new' },
+          { name: 'Existant (ajouter BYAN)', value: 'existing' },
+          { name: 'Migration (autre système)', value: 'migration' }
+        ]
+      },
+      {
+        type: 'checkbox',
+        name: 'objectives',
+        message: '2. Objectifs? (espace pour sélectionner)',
+        choices: [
+          { name: 'Créer des agents', value: 'agents', checked: true },
+          { name: 'Orchestrer workflows', value: 'workflows' },
+          { name: 'Automatiser tests', value: 'tests' },
+          { name: 'Analyser/documenter', value: 'analysis' },
+          { name: 'Voice dictation', value: 'voice' }
+        ],
+        validate: (a) => a.length > 0 ? true : 'Choisissez au moins un'
+      },
+      {
+        type: 'list',
+        name: 'teamSize',
+        message: '3. Taille équipe?',
+        choices: ['solo', 'small (2-5)', 'medium (6-15)', 'large (16+)']
+      },
+      {
+        type: 'list',
+        name: 'experience',
+        message: '4. Expérience AI?',
+        choices: ['beginner', 'intermediate', 'expert']
+      },
+      {
+        type: 'list',
+        name: 'connectivity',
+        message: '5. Connectivité?',
+        choices: ['online', 'offline', 'intermittent']
+      },
+      {
+        type: 'list',
+        name: 'gpu',
+        message: '6. GPU dispo (Turbo Whisper)?',
+        choices: ['yes (NVIDIA)', 'no (CPU)', 'unknown']
+      },
+      {
+        type: 'list',
+        name: 'methodology',
+        message: '7. Méthodologie?',
+        choices: ['merise-agile (BYAN native)', 'tdd', 'agile/scrum', 'hybrid']
+      },
+      {
+        type: 'list',
+        name: 'domain',
+        message: '8. Domaine?',
+        choices: ['web', 'backend/API', 'data/ML', 'mobile', 'devops', 'multi-domain']
+      },
+      {
+        type: 'list',
+        name: 'frequency',
+        message: '9. Fréquence?',
+        choices: ['daily', 'weekly', 'occasional']
+      },
+      {
+        type: 'list',
+        name: 'quality',
+        message: '10. Niveau qualité?',
+        choices: ['mvp (speed)', 'balanced', 'production', 'critical']
+      }
+    ]);
+    
+    // Build prompt for yanstaller agent with interview data + detected platforms
+    const interviewPrompt = [
+      `Analyse ce profil utilisateur et retourne UNIQUEMENT un JSON de recommandations.`,
+      `DETECTED PLATFORMS: copilot=${detectedPlatforms.copilot}, codex=${detectedPlatforms.codex}, claude=${detectedPlatforms.claude}`,
+      `PROJECT: type=${interviewAnswers.projectType}, domain=${interviewAnswers.domain}`,
+      `OBJECTIVES: ${interviewAnswers.objectives.join(',')}`,
+      `TEAM: ${interviewAnswers.teamSize}, EXPERIENCE: ${interviewAnswers.experience}`,
+      `CONNECTIVITY: ${interviewAnswers.connectivity}, GPU: ${interviewAnswers.gpu}`,
+      `METHODOLOGY: ${interviewAnswers.methodology}, FREQUENCY: ${interviewAnswers.frequency}`,
+      `QUALITY: ${interviewAnswers.quality}`,
+      `Retourne UNIQUEMENT un JSON valide avec: platforms (array), turboWhisper (mode/reason),`,
+      `agents (essential/optional arrays), modules (array), recommended_model (string).`,
+      `Format: {"platforms":[...],"turboWhisper":{"mode":"...","reason":"..."},`,
+      `"agents":{"essential":[...],"optional":[...]},"modules":[...],"recommended_model":"...","complexity_score":N}`
+    ].join(' ');
+    
+    // Calculate model for interview analysis based on complexity
+    const interviewComplexity = interviewAnswers.quality === 'critical' ? 'claude-haiku-4.5' : 'gpt-5-mini';
+    
+    // Pre-copy interview-only agent stub for Copilot CLI (requires .github/agents/ in CWD)
+    // This stub is self-contained - no external workflow references
+    // Codex and Claude use direct prompt execution, no agent stub needed
+    if (detectedPlatforms.copilot) {
+      const earlyGithubDir = path.join(projectRoot, '.github', 'agents');
+      const interviewAgentSource = path.join(templateDir, '.github', 'agents', 'bmad-agent-yanstaller-interview.md');
+      if (await fs.pathExists(interviewAgentSource)) {
+        await fs.ensureDir(earlyGithubDir);
+        await fs.copy(interviewAgentSource, path.join(earlyGithubDir, 'bmad-agent-yanstaller-interview.md'), { overwrite: true });
+      }
+    }
+    
+    // Write prompt to temp file to avoid shell escaping issues
+    const promptFile = path.join(projectRoot, '.yanstaller-prompt.tmp');
+    await fs.writeFile(promptFile, interviewPrompt, 'utf8');
+    
+    // Detect which CLI to use (non-interactive mode)
+    // Copilot: --agent loads from .github/agents/, -p for non-interactive, -s for silent
+    // Codex: exec subcommand for non-interactive, -m for model
+    // Claude: -p for non-interactive prompt
+    let agentCommand = null;
+    if (detectedPlatforms.copilot) {
+      agentCommand = `copilot --agent=bmad-agent-yanstaller-interview -p "$(cat '${promptFile}')" --model ${interviewComplexity} -s`;
+    } else if (detectedPlatforms.codex) {
+      agentCommand = `codex exec "$(cat '${promptFile}')"`;
+    } else if (detectedPlatforms.claude) {
+      agentCommand = `claude -p "$(cat '${promptFile}')"`;
+    }
+    
+    if (agentCommand) {
+      const agentSpinner = ora(`Analysing with yanstaller agent (${interviewComplexity})...`).start();
+      
+      try {
+        const result = execSync(agentCommand, {
+          encoding: 'utf8',
+          cwd: projectRoot,
+          timeout: 120000,
+          stdio: ['pipe', 'pipe', 'pipe']
+        });
+        
+        agentSpinner.succeed(`Analysis complete (model: ${interviewComplexity})`);
+        
+        // Parse JSON from agent response - extract last valid JSON block
+        const lines = result.split('\n');
+        let jsonStr = null;
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (trimmed.startsWith('{') && trimmed.includes('"platforms"')) {
+            try {
+              JSON.parse(trimmed);
+              jsonStr = trimmed;
+            } catch (e) { /* not valid JSON, try next line */ }
+          }
+        }
+        // Fallback: greedy regex match
+        if (!jsonStr) {
+          const jsonMatch = result.match(/\{[^{}]*"platforms"\s*:\s*\[[\s\S]*?\}[\s\S]*?\}/);
+          if (jsonMatch) jsonStr = jsonMatch[0];
+        }
+        if (jsonStr) {
+          try {
+            interviewResults = JSON.parse(jsonStr);
+            
+            console.log('');
+            console.log(chalk.cyan('📊 Yanstaller Recommendations:'));
+            if (interviewResults.platforms) {
+              console.log(chalk.green(`  Platforms: ${interviewResults.platforms.join(', ')}`));
+            }
+            if (interviewResults.turboWhisper) {
+              console.log(chalk.green(`  Turbo Whisper: ${interviewResults.turboWhisper.mode} (${interviewResults.turboWhisper.reason})`));
+            }
+            if (interviewResults.agents) {
+              console.log(chalk.green(`  Essential agents: ${interviewResults.agents.essential?.join(', ')}`));
+            }
+            if (interviewResults.modules) {
+              console.log(chalk.green(`  Modules: ${interviewResults.modules.join(', ')}`));
+            }
+            console.log(chalk.green(`  Model: ${interviewResults.recommended_model || interviewComplexity}`));
+            console.log(chalk.green(`  Complexity: ${interviewResults.complexity_score || 'N/A'}`));
+          } catch (parseErr) {
+            console.log(chalk.yellow('  ⚠ JSON parse error, using detection defaults'));
+            interviewResults = null;
+          }
+        } else {
+          console.log(chalk.yellow('  ⚠ No JSON in agent response, using detection defaults'));
+          interviewResults = null;
+        }
+      } catch (error) {
+        agentSpinner.warn(`Agent unavailable, using interview data directly`);
+        // Build recommendations locally from interview data
+        interviewResults = {
+          platforms: Object.entries(detectedPlatforms).filter(([,v]) => v).map(([k]) => k),
+          turboWhisper: {
+            mode: interviewAnswers.gpu.startsWith('yes') && (interviewAnswers.objectives.includes('voice') || interviewAnswers.frequency === 'daily') ? 'docker' : 
+                  interviewAnswers.objectives.includes('voice') || interviewAnswers.frequency === 'daily' ? 'local' : 'skip',
+            reason: interviewAnswers.objectives.includes('voice') ? 'Voice dictation selected' : 
+                    interviewAnswers.frequency === 'daily' ? 'Daily usage - productivity boost' : 'Based on interview'
+          },
+          agents: {
+            essential: ['byan', 'analyst'],
+            optional: interviewAnswers.experience === 'expert' ? ['dev', 'pm', 'architect', 'sm'] : ['dev']
+          },
+          modules: ['bmm', 'bmb'],
+          recommended_model: interviewComplexity,
+          complexity_score: 15
+        };
+        
+        console.log('');
+        console.log(chalk.cyan('📊 Local Recommendations (from interview):'));
+        console.log(chalk.green(`  Platforms: ${interviewResults.platforms.join(', ')}`));
+        console.log(chalk.green(`  Turbo Whisper: ${interviewResults.turboWhisper.mode}`));
+        console.log(chalk.green(`  Essential agents: ${interviewResults.agents.essential.join(', ')}`));
+        console.log(chalk.green(`  Model: ${interviewResults.recommended_model}`));
+      }
+    } else {
+      // No AI platform detected - build from interview data
+      interviewResults = {
+        platforms: ['copilot'],
+        turboWhisper: {
+          mode: interviewAnswers.gpu.startsWith('yes') && (interviewAnswers.objectives.includes('voice') || interviewAnswers.frequency === 'daily') ? 'docker' :
+                interviewAnswers.objectives.includes('voice') || interviewAnswers.frequency === 'daily' ? 'local' : 'skip',
+          reason: 'No AI platform detected'
+        },
+        agents: { essential: ['byan'], optional: [] },
+        modules: ['bmm', 'bmb'],
+        recommended_model: 'gpt-5-mini',
+        complexity_score: 15
+      };
+      
+      console.log(chalk.yellow('⚠ No AI platform detected, using defaults'));
+    }
+    
+    // Cleanup temp prompt file
+    await fs.remove(path.join(projectRoot, '.yanstaller-prompt.tmp')).catch(() => {});
+    
+    console.log('');
+  }
+  
+  // Step 3: Platform selection (with interview recommendations if CUSTOM mode)
+  let recommendedPlatforms = [];
+  let recommendedTurboWhisper = 'skip';
+  let autoSelectPlatform = null;
+  
+  if (installMode === 'custom' && interviewResults) {
+    // Use agent/interview recommendations
+    console.log(chalk.blue('🎯 Recommandations personnalisées:'));
+    console.log('');
+    
+    // Platform recommendations (from agent JSON or detected platforms)
+    const agentPlatforms = interviewResults.platforms || [];
+    if (agentPlatforms.length > 0) {
+      agentPlatforms.forEach(p => {
+        recommendedPlatforms.push(p);
+        console.log(chalk.green(`  ✓ ${p} - Recommandé par yanstaller`));
+      });
+    } else {
+      if (detectedPlatforms.copilot) { recommendedPlatforms.push('copilot'); console.log(chalk.green('  ✓ GitHub Copilot CLI - Détecté')); }
+      if (detectedPlatforms.codex) { recommendedPlatforms.push('codex'); console.log(chalk.green('  ✓ Codex - Détecté')); }
+      if (detectedPlatforms.claude) { recommendedPlatforms.push('claude'); console.log(chalk.green('  ✓ Claude Code - Détecté')); }
+    }
+    
+    // Turbo Whisper (from agent or interview data)
+    if (interviewResults.turboWhisper) {
+      recommendedTurboWhisper = interviewResults.turboWhisper.mode || 'skip';
+      if (recommendedTurboWhisper !== 'skip') {
+        console.log(chalk.cyan(`  🎤 Turbo Whisper (${recommendedTurboWhisper}) - ${interviewResults.turboWhisper.reason || 'Recommandé'}`));
+      }
+    }
+    
+    // Agents recommendation
+    if (interviewResults.agents) {
+      console.log(chalk.cyan(`  📦 Agents essentiels: ${(interviewResults.agents.essential || []).join(', ')}`));
+      if (interviewResults.agents.optional?.length > 0) {
+        console.log(chalk.gray(`  📦 Agents optionnels: ${interviewResults.agents.optional.join(', ')}`));
+      }
+    }
+    
+    // Model recommendation
+    if (interviewResults.recommended_model) {
+      console.log(chalk.cyan(`  🧠 Model recommandé: ${interviewResults.recommended_model} (score: ${interviewResults.complexity_score || 'N/A'})`));
+    }
+    
+    console.log('');
+    
+    // Phase 2: Interactive Chat with Yanstaller Agent
+    // Ask user if they want to enter Phase 2 conversation
+    const { enterPhase2 } = await inquirer.prompt([{
+      type: 'list',
+      name: 'enterPhase2',
+      message: 'Phase 2 - Configuration avancée?',
+      choices: [
+        { name: '💬 Chat - Conversation personnalisée avec Yanstaller', value: 'chat' },
+        { name: '⚡ Auto - Configuration par défaut (rapide)', value: 'auto' },
+        { name: '⏭️  Skip - Passer Phase 2', value: 'skip' }
+      ],
+      default: 'chat'
+    }]);
+    
+    let phase2Results = null;
+    
+    if (enterPhase2 === 'chat') {
+      // Launch interactive chat
+      phase2Results = await launchPhase2Chat({
+        interviewAnswers,
+        detectedPlatforms,
+        projectRoot,
+        templateDir,
+        userName: null, // Will be asked later
+        language: 'Francais'
+      });
+      
+      // If chat returned null, offer fallback
+      if (!phase2Results) {
+        console.log('');
+        const { useFallback } = await inquirer.prompt([{
+          type: 'confirm',
+          name: 'useFallback',
+          message: 'Utiliser la configuration par défaut?',
+          default: true
+        }]);
+        
+        if (useFallback) {
+          phase2Results = generateDefaultConfig(interviewAnswers, detectedPlatforms);
+        }
+      }
+    } else if (enterPhase2 === 'auto') {
+      // Use default configuration
+      const autoSpinner = ora('Generating default configuration...').start();
+      phase2Results = generateDefaultConfig(interviewAnswers, detectedPlatforms);
+      autoSpinner.succeed('Configuration generated');
+    }
+    
+    // Display Phase 2 results if available
+    if (phase2Results) {
+      console.log('');
+      console.log(chalk.cyan('📋 Configuration Agents:'));
+      if (phase2Results.coreAgents) {
+        console.log(chalk.green(`  Core: ${phase2Results.coreAgents.map(a => a.name).join(', ')}`));
+      }
+      if (phase2Results.agentRelationships?.length > 0) {
+        console.log(chalk.gray(`  Relations: ${phase2Results.agentRelationships.length} defined`));
+      }
+      if (phase2Results.customAgentsToCreate?.length > 0) {
+        console.log(chalk.yellow(`  À créer: ${phase2Results.customAgentsToCreate.map(a => a.name).join(', ')}`));
+      }
+      console.log('');
+      
+      // Generate project-agents.md
+      try {
+        const outputDir = path.join(projectRoot, '_byan-output');
+        const docPath = await generateProjectAgentsDoc(phase2Results, interviewAnswers, {}, outputDir);
+        console.log(chalk.green(`  ✓ Généré: ${path.relative(projectRoot, docPath)}`));
+        console.log('');
+      } catch (error) {
+        // Silent fail - document generation is optional
+      }
+    }
+    
+    autoSelectPlatform = recommendedPlatforms[0] || 'copilot';
+  }
+  
+  // Step 3: Platform selection (pre-select detected platforms)
+  const platformChoices = [
+    { name: `GitHub Copilot CLI ${detectedPlatforms.copilot ? chalk.green('(✓ Detected)') : ''}`, value: 'copilot' },
+    { name: `VSCode`, value: 'vscode' },
+    { name: `Claude Code ${detectedPlatforms.claude ? chalk.green('(✓ Detected)') : ''}`, value: 'claude' },
+    { name: `Codex ${detectedPlatforms.codex ? chalk.green('(✓ Detected)') : ''}`, value: 'codex' },
+    { name: 'All platforms', value: 'all' }
+  ];
+  
+  // Auto-select first detected platform as default (or use interview recommendation)
+  const defaultPlatform = (installMode === 'custom' && autoSelectPlatform) ? autoSelectPlatform :
+                          (detectedPlatforms.copilot ? 'copilot' :
+                           detectedPlatforms.codex ? 'codex' :
+                           detectedPlatforms.claude ? 'claude' : 'copilot');
+  
   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' }
-      ]
+      message: installMode === 'custom' ? 'Confirmer la plateforme (recommandation ci-dessus):' : 'Select platform to install for:',
+      choices: platformChoices,
+      default: defaultPlatform
     }
   ]);
   
@@ -238,7 +747,7 @@ async function install() {
       name: 'language',
       message: 'Communication language:',
       choices: ['Francais', 'English'],
-      default: 'English'
+      default: installMode === 'custom' && interviewResults ? 'Francais' : 'English'
     }
   ]);
   
@@ -272,21 +781,63 @@ async function install() {
     }
   }
   
-  // Step 6: Create directory structure (Platform - _bmad)
+  // Step 5.5: Turbo Whisper voice dictation (optional, with interview recommendation)
+  console.log(chalk.blue('\n🎤 Voice Dictation Setup'));
+  console.log(chalk.gray('Turbo Whisper enables voice-to-text with local Whisper AI server.\n'));
+  
+  let turboWhisperChoices = [
+    { name: '🖥️  Local (CPU) - Run Whisper server locally', value: 'local' },
+    { name: '🚀 Docker (GPU) - Run Whisper in Docker with GPU', value: 'docker' },
+    { name: '⏭️  Skip - Install later manually', value: 'skip' }
+  ];
+  
+  // Adjust default based on interview
+  let defaultTurboMode = 'skip';
+  if (installMode === 'custom' && recommendedTurboWhisper !== 'skip') {
+    defaultTurboMode = recommendedTurboWhisper;
+    console.log(chalk.cyan(`💡 Recommandation: ${recommendedTurboWhisper === 'docker' ? 'Docker (GPU)' : 'Local (CPU)'} basé sur votre profil\n`));
+  }
+  
+  const { turboWhisperMode } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'turboWhisperMode',
+      message: 'Install Turbo Whisper voice dictation?',
+      choices: turboWhisperChoices,
+      default: defaultTurboMode
+    }
+  ]);
+  
+  let turboWhisperInstalled = false;
+  
+  if (turboWhisperMode !== 'skip') {
+    try {
+      const TurboWhisperInstaller = require(path.join(__dirname, '..', 'setup-turbo-whisper.js'));
+      const turboInstaller = new TurboWhisperInstaller(projectRoot, turboWhisperMode);
+      const result = await turboInstaller.install();
+      turboWhisperInstalled = result.success;
+    } catch (error) {
+      console.error(chalk.red('Turbo Whisper installation failed:'), error.message);
+      console.log(chalk.yellow('You can install it later with: node install/setup-turbo-whisper.js'));
+      turboWhisperInstalled = false;
+    }
+  }
+  
+  // Step 6: Create directory structure (Platform - _byan)
   const installSpinner = ora('Creating directory structure...').start();
   
-  const bmadDir = path.join(projectRoot, '_bmad');
-  const bmbDir = path.join(bmadDir, 'bmb');
+  const byanDir = path.join(projectRoot, '_byan');
+  const bmbDir = path.join(byanDir, 'bmb');
   const githubAgentsDir = path.join(projectRoot, '.github', 'agents');
   
-  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'));
+  await fs.ensureDir(path.join(byanDir, 'bmb', 'agents'));
+  await fs.ensureDir(path.join(byanDir, 'bmb', 'workflows', 'byan', 'steps'));
+  await fs.ensureDir(path.join(byanDir, 'bmb', 'workflows', 'byan', 'templates'));
+  await fs.ensureDir(path.join(byanDir, 'bmb', 'workflows', 'byan', 'data'));
+  await fs.ensureDir(path.join(byanDir, 'core'));
+  await fs.ensureDir(path.join(byanDir, '_config'));
+  await fs.ensureDir(path.join(byanDir, '_memory'));
+  await fs.ensureDir(path.join(byanDir, '_output'));
   await fs.ensureDir(githubAgentsDir);
   
   installSpinner.succeed('Directory structure created');
@@ -296,7 +847,7 @@ async function install() {
   
   try {
     // Copy agent files
-    const agentsSource = path.join(templateDir, '_bmad', 'bmb', 'agents');
+    const agentsSource = path.join(templateDir, '_byan', 'bmb', 'agents');
     const agentsDest = path.join(bmbDir, 'agents');
     
     if (await fs.pathExists(agentsSource)) {
@@ -308,7 +859,7 @@ async function install() {
     }
     
     // Copy workflow files
-    const workflowsSource = path.join(templateDir, '_bmad', 'bmb', 'workflows', 'byan');
+    const workflowsSource = path.join(templateDir, '_byan', 'bmb', 'workflows', 'byan');
     const workflowsDest = path.join(bmbDir, 'workflows', 'byan');
     
     if (await fs.pathExists(workflowsSource)) {
@@ -341,11 +892,11 @@ async function install() {
   const configSpinner = ora('Generating configuration...').start();
   
   const configContent = {
-    bmb_creations_output_folder: "{project-root}/_bmad-output/bmb-creations",
+    bmb_creations_output_folder: "{project-root}/_byan-output/bmb-creations",
     user_name: config.userName,
     communication_language: config.language,
     document_output_language: config.language,
-    output_folder: "{project-root}/_bmad-output",
+    output_folder: "{project-root}/_byan-output",
     platform: platform,
     byan_version: v2Installed ? '2.0.0-alpha.1' : '1.0.0'
   };
@@ -426,15 +977,18 @@ async function install() {
   
   console.log(chalk.bold('Installation Summary:'));
   console.log(`  • Platform: ${chalk.cyan(platform)}`);
-  console.log(`  • Version: ${chalk.cyan(v2Installed ? 'v2.0.0-alpha.1 (Runtime + Platform)' : 'v1.0.0 (Platform only)')}`);
+  console.log(`  • Version: ${chalk.cyan(v2Installed ? 'v2.2.0 (Runtime + Platform + Model Selector)' : 'v2.2.0 (Platform only)')}`);
   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(`  • Turbo Whisper: ${chalk.cyan(turboWhisperInstalled ? `Installed (${turboWhisperMode} mode)` : 'Not installed')}`);
+  console.log(`  • Model Selector: ${chalk.cyan('Integrated (Auto cost optimization)')}`);
   
   if (v2Installed) {
-    console.log(chalk.cyan('\n  v2.0 Components Installed:'));
+    console.log(chalk.cyan('\n  v2.2 Components Installed:'));
     console.log(chalk.cyan('  ✓ Core: Context, Cache, Dispatcher, Worker Pool, Workflow'));
+    console.log(chalk.cyan('  ✓ Model Selector: Intelligent model selection'));
     console.log(chalk.cyan('  ✓ Observability: Logger, Metrics, Dashboard'));
     console.log(chalk.cyan('  ✓ Tests: 9 test suites with 364 tests'));
     console.log(chalk.cyan('  ✓ Entry Point: src/index.js'));
@@ -476,6 +1030,23 @@ async function install() {
     console.log('   Follow your platform\'s agent activation procedure');
   }
   
+  // Turbo Whisper instructions
+  if (turboWhisperInstalled) {
+    console.log('');
+    console.log(chalk.yellow('🎤 Turbo Whisper Voice Dictation:'));
+    console.log('');
+    
+    if (turboWhisperMode === 'local' || turboWhisperMode === 'docker') {
+      console.log(chalk.gray('  Lancement simplifié (1 commande):'));
+      console.log(`   ${chalk.blue('./scripts/launch-turbo-whisper.sh')}`);
+      console.log(chalk.gray('   → Démarre automatiquement le serveur si nécessaire'));
+      console.log('');
+    }
+    
+    console.log(chalk.gray('  Hotkey: Ctrl+Alt+R (start/stop recording)'));
+    console.log(chalk.gray('  Documentation: TURBO-WHISPER-SETUP.md'));
+  }
+  
   console.log('');
   console.log(chalk.gray('Need help? Type \'/bmad-help\' when BYAN is active'));
   console.log('');
@@ -485,7 +1056,7 @@ async function install() {
 // CLI Program
 program
   .name('create-byan-agent')
-  .description('Install BYAN v2.0 - Builder of YAN agent creator with v2.0 runtime support')
+  .description('Install BYAN v2.2.0 - Builder of YAN with Model Selector and multi-platform support')
   .version(BYAN_VERSION)
   .action(install);