create-byan-agent 2.7.1 → 2.7.2

package/lib/phase2-chat.js

@@ -0,0 +1,534 @@
+/**
+ * Phase 2 Chat - Integrated conversation within the wizard
+ * 
+ * Provides an in-wizard chat experience with the yanstaller-phase2 agent
+ * using copilot/codex CLI for AI responses.
+ */
+
+const { spawnSync } = require('child_process');
+const path = require('path');
+const os = require('os');
+const fs = require('fs-extra');
+const inquirer = require('inquirer');
+const chalk = require('chalk');
+const ora = require('ora');
+
+/**
+ * Cross-platform CLI command execution
+ * Uses spawnSync without shell on Unix (no character interpretation)
+ * Uses shell on Windows for .cmd file support
+ */
+function runCliCommand(cmd, args, cwd, stdinInput) {
+  const isWindows = process.platform === 'win32';
+  const opts = {
+    encoding: 'utf8',
+    cwd: cwd,
+    timeout: 60000,
+    maxBuffer: 1024 * 1024,
+    stdio: ['pipe', 'pipe', 'pipe']
+  };
+  
+  if (stdinInput) opts.input = stdinInput;
+  if (isWindows) opts.shell = true;
+  
+  const res = spawnSync(cmd, args, opts);
+  if (res.error) throw res.error;
+  
+  // Check for non-zero exit code with stderr
+  if (res.status !== 0 && res.stderr) {
+    const stderr = res.stderr.toString().trim();
+    if (stderr) throw new Error(stderr);
+  }
+  
+  return (res.stdout || '').toString();
+}
+
+/**
+ * Build the initial context prompt from Phase 1 answers
+ */
+function buildPhase1Context(interviewAnswers, detectedPlatforms, userName, language) {
+  const platformsDetected = [];
+  if (detectedPlatforms.copilot) platformsDetected.push('GitHub Copilot CLI');
+  if (detectedPlatforms.codex) platformsDetected.push('OpenAI Codex');
+  if (detectedPlatforms.claude) platformsDetected.push('Claude Code');
+  if (detectedPlatforms.vscode) platformsDetected.push('VSCode');
+  
+  return {
+    user_name: userName || 'Developer',
+    communication_language: language || 'Francais',
+    project_type: interviewAnswers.projectType,
+    objectives: interviewAnswers.objectives,
+    team_size: interviewAnswers.teamSize,
+    experience: interviewAnswers.experience,
+    connectivity: interviewAnswers.connectivity,
+    gpu_available: interviewAnswers.gpu,
+    methodology: interviewAnswers.methodology,
+    domain: interviewAnswers.domain,
+    frequency: interviewAnswers.frequency,
+    quality_level: interviewAnswers.quality,
+    platforms_detected: platformsDetected,
+    platforms_string: platformsDetected.join(', ') || 'None'
+  };
+}
+
+/**
+ * Generate the pre-prompt for Phase 2 agent
+ */
+function generatePhase2Preprompt(context) {
+  return `
+## Profil Utilisateur Phase 1
+
+- **Nom**: ${context.user_name}
+- **Langue**: ${context.communication_language}
+- **Type de projet**: ${context.project_type}
+- **Domaine**: ${context.domain}
+- **Objectifs**: ${Array.isArray(context.objectives) ? context.objectives.join(', ') : context.objectives}
+- **Taille équipe**: ${context.team_size}
+- **Expérience AI**: ${context.experience}
+- **Connectivité**: ${context.connectivity}
+- **GPU disponible**: ${context.gpu_available}
+- **Méthodologie**: ${context.methodology}
+- **Fréquence utilisation**: ${context.frequency}
+- **Niveau qualité**: ${context.quality_level}
+- **Plateformes détectées**: ${context.platforms_string}
+
+## Écosystème BYAN - Agents Disponibles
+
+### 🏛️ Hermes - Dispatcher Universel (NOUVEAU v2.3.2)
+**Point d'entrée intelligent vers tout l'écosystème BYAN**
+- **Rôle**: Router intelligent + Agent directory + Pipeline orchestrator
+- **Invocation**: \`@hermes\`
+- **Capabilities**:
+  - [LA] Liste 35+ agents par module (core, bmm, bmb, cis, tea)
+  - [REC] Smart routing: décris ta tâche → Hermes recommande les meilleurs agents
+  - [PIPE] Pipelines multi-agents (Feature Complete, Bug Fix, Idea→Code, etc.)
+  - [@agent] Invocation directe d'agents
+  - [?agent] Quick help sans charger l'agent
+- **Quand recommander Hermes**: Toujours! C'est le meilleur point de départ pour découvrir et utiliser les agents BYAN.
+
+### 📦 Core Module (Foundation)
+- **bmad-master**: Executor & Orchestrator (workflows, tasks)
+- **yanstaller**: Smart installer (c'est moi!)
+- **expert-merise-agile**: Conception Merise Agile + MCD/MCT
+
+### 🔨 BMB Module (Builders)
+- **byan**: Agent creator via interview (12 questions, 64 mantras)
+- **byan-v2**: Optimized BYAN v2
+- **agent-builder**: Construction expert
+- **marc**: GitHub Copilot integration specialist
+- **rachid**: NPM/NPX deployment specialist
+- **carmack**: Token optimizer
+- **patnote**: Update manager
+
+### 💼 BMM Module (Management - SDLC)
+- **analyst** (Mary): Business analysis, market research
+- **architect** (Winston): System design, tech stack
+- **dev** (Amelia): Implementation, coding
+- **pm** (John): Product management, PRD
+- **sm** (Bob): Scrum master, sprint planning
+- **quinn**: QA engineer, tests
+- **tech-writer** (Paige): Documentation
+- **ux-designer** (Sally): UX/UI design
+- **quick-flow-solo-dev** (Barry): Fast brownfield dev
+
+### 🎨 CIS Module (Creative & Innovation)
+- **brainstorming-coach** (Carson): Ideation sessions
+- **creative-problem-solver** (Dr. Quinn): Problem solving
+- **design-thinking-coach** (Maya): Design thinking
+- **innovation-strategist** (Victor): Innovation strategy
+- **presentation-master** (Caravaggio): Presentations, slides
+- **storyteller** (Sophia): Storytelling, narratives
+
+### 🧪 TEA Module (Testing)
+- **tea** (Murat): Master test architect (ATDD, NFR, CI/CD)
+
+## Workflows Prédéfinis (via Hermes)
+
+1. **Feature Complete**: PM → Architect → UX → SM → Dev → Tea
+2. **Idea to Code**: PM → Architect → SM → Quick Flow
+3. **New Agent**: BYAN (handles entire flow)
+4. **Refactoring**: Architect → Dev → Tea
+5. **Bug Fix**: Dev → Quinn
+6. **Documentation**: Analyst → Tech Writer
+7. **Quality Complete**: Tea → Quinn → code-review
+
+## Instructions
+
+Tu es YANSTALLER Phase 2. Commence par accueillir ${context.user_name} avec un résumé de son profil, puis engage une conversation pour configurer son écosystème d'agents BYAN.
+
+**IMPORTANT**: Tu connais maintenant HERMES (v2.3.2) - le dispatcher universel. Recommande-le systématiquement comme point d'entrée pour découvrir et orchestrer les agents.
+
+Adapte tes questions au domaine "${context.domain}" et au niveau d'expérience "${context.experience}".
+
+Quand l'utilisateur dit "finaliser", "terminer" ou "c'est bon", génère la configuration JSON finale.
+`.trim();
+}
+
+/**
+ * Send a message to the AI and get a response
+ * 
+ * @param {string} message User message
+ * @param {string} systemContext System context/preprompt
+ * @param {string} conversationHistory Previous conversation
+ * @param {string} selectedPlatform Selected AI platform
+ * @param {string} projectRoot Project root directory
+ * @returns {Promise<string>} AI response
+ */
+async function sendChatMessage(message, systemContext, conversationHistory, selectedPlatform, projectRoot) {
+  const fullPrompt = `${systemContext}
+
+## Historique de conversation:
+${conversationHistory}
+
+## Message utilisateur:
+${message}
+
+## Instructions:
+Réponds de manière concise et naturelle. Si l'utilisateur dit "finaliser", génère le JSON de configuration.
+Continue la conversation pour comprendre le projet et personnaliser les agents.`;
+
+  let result = '';
+  
+  try {
+    if (selectedPlatform === 'copilot') {
+      result = runCliCommand('copilot', ['-p', fullPrompt, '-s'], projectRoot);
+    } else if (selectedPlatform === 'codex') {
+      // Codex takes prompt as argument to exec command
+      // --skip-git-repo-check needed when not in a trusted git repo
+      result = runCliCommand('codex', ['exec', '--skip-git-repo-check', fullPrompt], projectRoot);
+    } else if (selectedPlatform === 'claude') {
+      // Claude: separate system prompt from user query
+      // -p treats arg as user query; system context goes via --append-system-prompt-file
+      const claudeSystemCtx = `${systemContext}\n\n## Historique de conversation:\n${conversationHistory}\n\n## Instructions:\nRéponds de manière concise et naturelle. Si l'utilisateur dit "finaliser", génère le JSON de configuration.\nContinue la conversation pour comprendre le projet et personnaliser les agents.`;
+      const tmpFile = path.join(os.tmpdir(), `byan-claude-ctx-${Date.now()}.txt`);
+      fs.writeFileSync(tmpFile, claudeSystemCtx, 'utf8');
+      try {
+        result = runCliCommand('claude', [
+          '-p', message,
+          '--append-system-prompt-file', tmpFile
+        ], projectRoot);
+      } finally {
+        try { fs.unlinkSync(tmpFile); } catch(e) {}
+      }
+    } else {
+      throw new Error(`Platform not supported: ${selectedPlatform}`);
+    }
+  } catch (error) {
+    const errMsg = (error.message || '').toLowerCase();
+    console.error(chalk.red(`\n❌ Erreur ${selectedPlatform}: ${error.message}`));
+    
+    // Platform-specific login guidance
+    if (selectedPlatform === 'claude' && (errMsg.includes('auth') || errMsg.includes('api') || errMsg.includes('key') || errMsg.includes('login') || errMsg.includes('401'))) {
+      console.log('');
+      console.log(chalk.yellow('  💡 Pour se connecter à Claude Code:'));
+      console.log(chalk.cyan('     1. claude login'));
+      console.log(chalk.gray('     2. ou: export ANTHROPIC_API_KEY=sk-ant-...'));
+      console.log(chalk.gray('     3. ou dans Claude Code: /login'));
+    } else if (selectedPlatform === 'copilot') {
+      console.log(chalk.gray('     → copilot auth'));
+    } else if (selectedPlatform === 'codex') {
+      console.log(chalk.gray('     → codex login'));
+    }
+    
+    result = `Désolé, erreur de communication avec ${selectedPlatform}. Réessayez ou tapez "skip".`;
+  }
+  
+  result = result.replace(/\x1b\[[0-9;]*m/g, '').trim();
+  return result;
+}
+
+/**
+ * Launch integrated chat within the wizard
+ * 
+ * @param {Object} options Configuration options
+ * @param {Object} options.interviewAnswers Phase 1 answers
+ * @param {Object} options.detectedPlatforms Detected AI platforms
+ * @param {string} options.selectedPlatform Selected AI platform to use
+ * @param {string} options.projectRoot Project root directory
+ * @param {string} options.templateDir Templates directory
+ * @param {string} options.userName User name
+ * @param {string} options.language Communication language
+ * @returns {Promise<Object|null>} Phase 2 results or null if cancelled
+ */
+async function launchPhase2Chat(options) {
+  const {
+    interviewAnswers,
+    detectedPlatforms,
+    selectedPlatform,
+    projectRoot,
+    templateDir,
+    userName,
+    language
+  } = options;
+  
+  // Build context from Phase 1
+  const context = buildPhase1Context(interviewAnswers, detectedPlatforms, userName, language);
+  const systemContext = generatePhase2Preprompt(context);
+  
+  // Pre-copy Phase 2 agent to project
+  const phase2AgentSource = path.join(templateDir, '.github', 'agents', 'bmad-agent-yanstaller-phase2.md');
+  const githubAgentsDir = path.join(projectRoot, '.github', 'agents');
+  
+  if (await fs.pathExists(phase2AgentSource)) {
+    await fs.ensureDir(githubAgentsDir);
+    await fs.copy(phase2AgentSource, path.join(githubAgentsDir, 'bmad-agent-yanstaller-phase2.md'), { overwrite: true });
+  }
+  
+  // Display Phase 2 header
+  console.log('');
+  console.log(chalk.magenta('╔════════════════════════════════════════════════════════════╗'));
+  console.log(chalk.magenta('║') + '                                                            ' + chalk.magenta('║'));
+  console.log(chalk.magenta('║') + `   ${chalk.bold('💬 PHASE 2 - Conversation Yanstaller')}                      ` + chalk.magenta('║'));
+  console.log(chalk.magenta('║') + `   ${chalk.gray(`Mode interactif - Domaine: ${context.domain}`)}                     ` + chalk.magenta('║'));
+  console.log(chalk.magenta('║') + '                                                            ' + chalk.magenta('║'));
+  console.log(chalk.magenta('╚════════════════════════════════════════════════════════════╝'));
+  console.log('');
+  console.log(chalk.gray('  Commandes: "finaliser" | "skip" | "aide"'));
+  console.log('');
+  
+  // Check if any AI platform is available
+  if (!detectedPlatforms.copilot && !detectedPlatforms.codex && !detectedPlatforms.claude) {
+    console.log(chalk.yellow('  ⚠ Aucune plateforme AI détectée pour le chat.'));
+    return null;
+  }
+  
+  // Get initial AI greeting
+  const spinner = ora('Yanstaller réfléchit...').start();
+  let conversationHistory = '';
+  
+  const initialMessage = `Commence par accueillir l'utilisateur ${context.user_name} avec un résumé de son profil (domaine: ${context.domain}, objectifs: ${context.objectives ? context.objectives.join(', ') : 'non spécifiés'}) et pose ta première question pour personnaliser son installation BYAN.`;
+  
+  const greeting = await sendChatMessage(initialMessage, systemContext, '', selectedPlatform, projectRoot);
+  spinner.stop();
+  
+  console.log(chalk.cyan('  Yanstaller:'));
+  console.log(chalk.white('  ' + greeting.split('\n').join('\n  ')));
+  console.log('');
+  
+  conversationHistory += `Assistant: ${greeting}\n\n`;
+  
+  // Chat loop using inquirer (avoids readline/inquirer conflict)
+  let phase2Config = null;
+  let continueChat = true;
+  
+  while (continueChat) {
+    // Get user input using inquirer
+    const { userInput } = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'userInput',
+        message: '> Vous:',
+        prefix: ' '
+      }
+    ]);
+    
+    const input = userInput.trim().toLowerCase();
+    
+    // Handle special commands
+    if (input === 'skip' || input === 'passer') {
+      console.log(chalk.gray('  Phase 2 ignorée.'));
+      return null;
+    }
+    
+    if (input === 'aide' || input === 'help') {
+      console.log('');
+      console.log(chalk.cyan('  Commandes disponibles:'));
+      console.log(chalk.gray('    finaliser - Générer la configuration et continuer'));
+      console.log(chalk.gray('    skip      - Passer cette phase'));
+      console.log(chalk.gray('    aide      - Afficher cette aide'));
+      console.log('');
+      continue;
+    }
+    
+    // Add user message to history
+    conversationHistory += `Utilisateur: ${userInput}\n\n`;
+    
+    // Check for finalization
+    const wantsFinal = input.includes('finaliser') || 
+                      input.includes('terminer') || 
+                      input.includes('c\'est bon') ||
+                      input.includes('fini');
+    
+    // Send to AI
+    const chatSpinner = ora('Yanstaller réfléchit...').start();
+    
+    let aiPrompt = userInput;
+    if (wantsFinal) {
+      aiPrompt = `${userInput}
+
+IMPORTANT: L'utilisateur veut finaliser. Génère maintenant la configuration JSON complète avec ce format exact:
+\`\`\`json
+{
+  "coreAgents": [...],
+  "optionalAgents": [...],
+  "agentRelationships": [...],
+  "projectStructure": {...},
+  "customAgentsToCreate": [...],
+  "recommendedModel": "string",
+  "rationale": "string"
+}
+\`\`\``;
+    }
+    
+    const response = await sendChatMessage(aiPrompt, systemContext, conversationHistory, selectedPlatform, projectRoot);
+    chatSpinner.stop();
+    
+    console.log('');
+    console.log(chalk.cyan('  Yanstaller:'));
+    console.log(chalk.white('  ' + response.split('\n').join('\n  ')));
+    console.log('');
+    
+    conversationHistory += `Assistant: ${response}\n\n`;
+    
+    // Try to extract JSON config from response
+    const jsonMatch = response.match(/```json\s*([\s\S]*?)```/) || 
+                     response.match(/\{[\s\S]*"coreAgents"[\s\S]*\}/);
+    
+    if (jsonMatch) {
+      try {
+        const jsonStr = jsonMatch[1] || jsonMatch[0];
+        phase2Config = JSON.parse(jsonStr.trim());
+        console.log(chalk.green('  ✓ Configuration extraite!'));
+        console.log('');
+        continueChat = false;
+      } catch (e) {
+        // JSON parse failed, continue conversation
+      }
+    }
+    
+    // If user wanted to finalize but we didn't get valid JSON
+    if (wantsFinal && !phase2Config) {
+      console.log(chalk.yellow('  ⚠ Configuration non générée. Réessayez "finaliser" ou "skip".'));
+      console.log('');
+    }
+  }
+  
+  return phase2Config;
+}
+
+/**
+ * Fallback: Generate default config based on Phase 1 answers only
+ */
+function generateDefaultConfig(interviewAnswers, detectedPlatforms, selectedPlatform) {
+  const domain = interviewAnswers.domain;
+  const quality = interviewAnswers.quality;
+  
+  // Domain-based defaults
+  const domainConfigs = {
+    'devops': {
+      coreAgents: [
+        { name: 'byan', role: 'Meta-agent creator', expertise: ['agent orchestration'], complexity: 'simple' },
+        { name: 'architect', role: 'Infrastructure design', expertise: ['cloud architecture', 'IaC'], complexity: 'complex' },
+        { name: 'devops', role: 'CI/CD pipeline management', expertise: ['automation', 'deployment'], complexity: 'complex' },
+        { name: 'security', role: 'Security scanning', expertise: ['container security', 'vulnerability analysis'], complexity: 'medium' }
+      ],
+      optionalAgents: [
+        { name: 'quinn', role: 'QA automation', expertise: ['testing'], when: 'Integration tests needed' }
+      ],
+      customAgentsToCreate: [
+        { name: 'pipeline-orchestrator', template: 'dev', focus: 'CI/CD optimization', mantras: ['IA-3 Automate Repeatable Work'] }
+      ],
+      projectStructure: { type: 'monorepo', folders: ['infra/', 'pipelines/', 'scripts/'], keyFiles: ['.github/workflows/', 'Dockerfile'] }
+    },
+    'web': {
+      coreAgents: [
+        { name: 'byan', role: 'Meta-agent creator', expertise: ['agent orchestration'], complexity: 'simple' },
+        { name: 'ux-designer', role: 'User experience design', expertise: ['UI/UX', 'accessibility'], complexity: 'medium' },
+        { name: 'dev', role: 'Frontend development', expertise: ['React', 'CSS', 'TypeScript'], complexity: 'medium' },
+        { name: 'quinn', role: 'QA automation', expertise: ['E2E testing', 'visual regression'], complexity: 'medium' }
+      ],
+      optionalAgents: [
+        { name: 'tech-writer', role: 'Documentation', expertise: ['docs'], when: 'API documentation needed' }
+      ],
+      customAgentsToCreate: [
+        { name: 'component-architect', template: 'architect', focus: 'Component library design', mantras: ['IA-24 Clean Code'] }
+      ],
+      projectStructure: { type: 'monorepo', folders: ['src/', 'components/', 'tests/'], keyFiles: ['package.json', 'tsconfig.json'] }
+    },
+    'backend/API': {
+      coreAgents: [
+        { name: 'byan', role: 'Meta-agent creator', expertise: ['agent orchestration'], complexity: 'simple' },
+        { name: 'architect', role: 'API design', expertise: ['REST', 'GraphQL', 'database'], complexity: 'complex' },
+        { name: 'dev', role: 'Backend development', expertise: ['Node.js', 'Python', 'Go'], complexity: 'medium' },
+        { name: 'data-analyst', role: 'Data modeling', expertise: ['Merise', 'SQL'], complexity: 'medium' }
+      ],
+      optionalAgents: [
+        { name: 'security', role: 'API security', expertise: ['OWASP'], when: 'Production deployment' }
+      ],
+      customAgentsToCreate: [
+        { name: 'api-designer', template: 'architect', focus: 'API contract design', mantras: ['IA-1 Trust But Verify'] }
+      ],
+      projectStructure: { type: 'microservices', folders: ['src/', 'api/', 'models/', 'tests/'], keyFiles: ['openapi.yaml', 'docker-compose.yml'] }
+    },
+    'data/ML': {
+      coreAgents: [
+        { name: 'byan', role: 'Meta-agent creator', expertise: ['agent orchestration'], complexity: 'simple' },
+        { name: 'data-analyst', role: 'Data engineering', expertise: ['ETL', 'data modeling'], complexity: 'complex' },
+        { name: 'dev', role: 'ML development', expertise: ['Python', 'TensorFlow', 'PyTorch'], complexity: 'complex' },
+        { name: 'architect', role: 'Data architecture', expertise: ['data lakes', 'pipelines'], complexity: 'complex' }
+      ],
+      optionalAgents: [
+        { name: 'quinn', role: 'Model validation', expertise: ['testing'], when: 'Model accuracy validation needed' }
+      ],
+      customAgentsToCreate: [
+        { name: 'ml-ops', template: 'devops', focus: 'ML pipeline automation', mantras: ['IA-3 Automate Repeatable Work'] }
+      ],
+      projectStructure: { type: 'monorepo', folders: ['data/', 'models/', 'notebooks/', 'pipelines/'], keyFiles: ['requirements.txt', 'dvc.yaml'] }
+    },
+    'mobile': {
+      coreAgents: [
+        { name: 'byan', role: 'Meta-agent creator', expertise: ['agent orchestration'], complexity: 'simple' },
+        { name: 'ux-designer', role: 'Mobile UX', expertise: ['iOS HIG', 'Material Design'], complexity: 'medium' },
+        { name: 'dev', role: 'Mobile development', expertise: ['React Native', 'Flutter', 'Swift'], complexity: 'medium' },
+        { name: 'quinn', role: 'Mobile testing', expertise: ['device testing', 'performance'], complexity: 'medium' }
+      ],
+      optionalAgents: [
+        { name: 'architect', role: 'App architecture', expertise: ['offline-first'], when: 'Offline support needed' }
+      ],
+      customAgentsToCreate: [
+        { name: 'platform-specialist', template: 'dev', focus: 'Platform-specific optimizations', mantras: ['IA-24 Clean Code'] }
+      ],
+      projectStructure: { type: 'monorepo', folders: ['src/', 'ios/', 'android/', 'shared/'], keyFiles: ['app.json', 'package.json'] }
+    },
+    'multi-domain': {
+      coreAgents: [
+        { name: 'byan', role: 'Meta-agent creator', expertise: ['agent orchestration'], complexity: 'simple' },
+        { name: 'analyst', role: 'Requirements analysis', expertise: ['Merise', 'user stories'], complexity: 'medium' },
+        { name: 'architect', role: 'System design', expertise: ['full-stack architecture'], complexity: 'complex' },
+        { name: 'dev', role: 'Full-stack development', expertise: ['versatile'], complexity: 'medium' }
+      ],
+      optionalAgents: [
+        { name: 'pm', role: 'Project management', expertise: ['prioritization'], when: 'Multiple stakeholders' }
+      ],
+      customAgentsToCreate: [],
+      projectStructure: { type: 'monorepo', folders: ['frontend/', 'backend/', 'shared/', 'docs/'], keyFiles: ['package.json', 'docker-compose.yml'] }
+    }
+  };
+  
+  const config = domainConfigs[domain] || domainConfigs['multi-domain'];
+  
+  // Add common fields
+  config.agentRelationships = [
+    { from: 'analyst', to: 'architect', type: 'informs', description: 'Requirements inform architecture decisions' },
+    { from: 'architect', to: 'dev', type: 'triggers', description: 'Architecture triggers implementation' }
+  ];
+  
+  // Set model based on quality and selected platform
+  if (selectedPlatform === 'claude') {
+    config.recommendedModel = quality === 'critical' ? 'claude-sonnet-4' : 'claude-haiku-4.5';
+  } else {
+    config.recommendedModel = quality === 'critical' ? 'claude-sonnet-4' : 
+                              quality === 'production' ? 'gpt-5.1-codex' : 'gpt-5-mini';
+  }
+  
+  config.rationale = `Configuration par défaut pour projet ${domain}. Personnalisez via la conversation Phase 2 pour plus de précision.`;
+  
+  return config;
+}
+
+module.exports = {
+  launchPhase2Chat,
+  generateDefaultConfig,
+  buildPhase1Context,
+  generatePhase2Preprompt
+};