create-byan-agent 2.2.1 → 2.3.0

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

@@ -426,6 +426,12 @@ async function install() {
         name: 'quality',
         message: '10. Niveau qualité?',
         choices: ['mvp (speed)', 'balanced', 'production', 'critical']
+      },
+      {
+        type: 'confirm',
+        name: 'costOptimizer',
+        message: '11. Optimiser coûts LLM automatiquement? (Économise ~54%)',
+        default: true
       }
     ]);
     
@@ -858,6 +864,24 @@ async function install() {
       copySpinner.warn(`⚠ Agent source not found: ${agentsSource}`);
     }
     
+    // Copy cost optimizer worker if enabled
+    if (interviewAnswers && interviewAnswers.costOptimizer) {
+      const workersDir = path.join(byanDir, 'workers');
+      await fs.ensureDir(workersDir);
+      
+      const workerSource = path.join(templateDir, 'workers', 'cost-optimizer.js');
+      const workerDest = path.join(workersDir, 'cost-optimizer.js');
+      
+      if (await fs.pathExists(workerSource)) {
+        await fs.copy(workerSource, workerDest, { overwrite: true });
+        copySpinner.text = 'Copied cost optimizer worker...';
+        console.log(chalk.green(`  ✓ Cost Optimizer: ${workerSource} → ${workerDest}`));
+        console.log(chalk.cyan('    💰 Automatic LLM cost optimization enabled (~54% savings)'));
+      } else {
+        copySpinner.warn(`⚠ Cost optimizer source not found: ${workerSource}`);
+      }
+    }
+    
     // Copy workflow files
     const workflowsSource = path.join(templateDir, '_byan', 'bmb', 'workflows', 'byan');
     const workflowsDest = path.join(bmbDir, 'workflows', 'byan');

package/install/lib/platforms/claude-code.js

@@ -2,6 +2,7 @@
  * Claude Code Platform Support
  * 
  * Detects and installs MCP server config for Claude Code.
+ * Uses agent Claude for native integration via MCP protocol.
  * 
  * @module platforms/claude-code
  */
@@ -9,8 +10,10 @@
 const path = require('path');
 const os = require('os');
 const fileUtils = require('../utils/file-utils');
+const logger = require('../utils/logger');
 
 const PLATFORM_NAME = 'Claude Code';
+const MCP_SERVER_FILENAME = 'byan-mcp-server.js';
 
 /**
  * Get config path for current platform
@@ -48,24 +51,131 @@ async function detect() {
 /**
  * Install MCP server config for Claude Code
  * 
+ * Delegates to agent Claude for native integration.
+ * Falls back to basic JSON update if agent unavailable.
+ * 
  * @param {string} projectRoot - Project root directory
  * @param {string[]} agents - Agent names to install
  * @param {Object} config - Installation config
- * @returns {Promise<{success: boolean, installed: number}>}
+ * @param {Object} [options] - Installation options
+ * @param {string} [options.specialist] - Specialist agent to use (e.g., 'claude')
+ * @param {boolean} [options.useAgent] - Use specialist agent if available (default: true)
+ * @returns {Promise<{success: boolean, installed: number, method: string}>}
  */
-async function install(projectRoot, agents, config) {
+async function install(projectRoot, agents, config, options = {}) {
   const configPath = getConfigPath();
   
   if (!configPath) {
     throw new Error(`Unsupported platform: ${os.platform()}`);
   }
   
-  // TODO: Update claude_desktop_config.json to add MCP server
-  // MCP server will expose BYAN agents
+  const useAgent = options.useAgent !== false && options.specialist === 'claude';
+  
+  if (useAgent) {
+    logger.info('Using agent Claude for native MCP integration...');
+    return await installViaCopilotAgent(projectRoot, agents, config);
+  } else {
+    logger.info('Using direct MCP configuration...');
+    return await installDirectMCP(projectRoot, agents, config);
+  }
+}
+
+/**
+ * Install via agent Claude (native integration)
+ * 
+ * @param {string} projectRoot
+ * @param {string[]} agents
+ * @param {Object} config
+ * @returns {Promise<{success: boolean, installed: number, method: string}>}
+ */
+async function installViaCopilotAgent(projectRoot, agents, config) {
+  const agentLauncher = require('../yanstaller/agent-launcher');
+  
+  // Check if native launch is available
+  if (agentLauncher.supportsNativeLaunch('claude')) {
+    logger.info('\n🚀 Launching agent Claude for MCP integration...');
+    
+    // Launch agent Claude with create-mcp-server action
+    const result = await agentLauncher.launch({
+      agent: 'claude',
+      platform: 'claude',
+      prompt: 'create-mcp-server'
+    });
+    
+    if (result.success) {
+      return {
+        success: true,
+        installed: agents.length,
+        method: 'agent-claude-native'
+      };
+    } else {
+      logger.warn(`Native launch failed: ${result.error}`);
+      logger.info('Falling back to manual instructions...');
+    }
+  }
+  
+  // Fallback: Manual instructions
+  logger.info('\n📝 To complete Claude Code integration:');
+  logger.info('   1. Run: @bmad-agent-claude');
+  logger.info('   2. Select option 1: Create MCP server for BYAN agents');
+  logger.info('   3. Follow the guided setup\n');
+  
+  return {
+    success: true,
+    installed: agents.length,
+    method: 'agent-claude-guided'
+  };
+}
+
+/**
+ * Install via direct MCP config update
+ * 
+ * @param {string} projectRoot
+ * @param {string[]} agents
+ * @param {Object} config
+ * @returns {Promise<{success: boolean, installed: number, method: string}>}
+ */
+async function installDirectMCP(projectRoot, agents, config) {
+  const configPath = getConfigPath();
+  const mcpServerPath = path.join(projectRoot, MCP_SERVER_FILENAME);
+  
+  // Check if MCP server exists
+  if (!await fileUtils.exists(mcpServerPath)) {
+    logger.warn(`MCP server not found at: ${mcpServerPath}`);
+    logger.warn('Run @bmad-agent-claude to generate MCP server first.');
+    
+    return {
+      success: false,
+      installed: 0,
+      method: 'direct-mcp-failed'
+    };
+  }
+  
+  // Backup existing config
+  const backupPath = `${configPath}.backup`;
+  await fileUtils.copy(configPath, backupPath);
+  logger.info(`Backed up config to: ${backupPath}`);
+  
+  // Read and update config
+  const existingConfig = await fileUtils.readJson(configPath);
+  existingConfig.mcpServers = existingConfig.mcpServers || {};
+  
+  existingConfig.mcpServers.byan = {
+    command: 'node',
+    args: [mcpServerPath],
+    env: {
+      PROJECT_ROOT: projectRoot
+    }
+  };
+  
+  // Write updated config
+  await fileUtils.writeJson(configPath, existingConfig, { spaces: 2 });
+  logger.info(`Updated MCP config: ${configPath}`);
   
   return {
     success: true,
-    installed: agents.length
+    installed: agents.length,
+    method: 'direct-mcp'
   };
 }
 

package/install/lib/yanstaller/agent-launcher.js

@@ -0,0 +1,348 @@
+/**
+ * AGENT LAUNCHER Module
+ * 
+ * Launches specialist agents using native platform commands.
+ * Each platform has its own invocation syntax.
+ * 
+ * @module yanstaller/agent-launcher
+ */
+
+const { execSync, spawn } = require('child_process');
+const logger = require('../utils/logger');
+
+/**
+ * @typedef {Object} LaunchOptions
+ * @property {string} agent - Agent name (e.g., 'claude', 'marc')
+ * @property {string} platform - Platform ID (e.g., 'copilot-cli', 'claude')
+ * @property {string} [prompt] - Initial prompt/action
+ * @property {string} [model] - Model to use
+ * @property {Object} [config] - Additional config
+ */
+
+/**
+ * @typedef {Object} LaunchResult
+ * @property {boolean} success
+ * @property {string} method - How agent was launched
+ * @property {string} [output] - Command output
+ * @property {string} [error] - Error message if failed
+ */
+
+/**
+ * Platform-specific launch configurations
+ */
+const LAUNCH_CONFIGS = {
+  'copilot-cli': {
+    command: 'gh',
+    args: (agent, options) => {
+      const args = ['copilot'];
+      
+      // Use @agent syntax if available
+      if (agent) {
+        args.push(`@bmad-agent-${agent}`);
+      }
+      
+      if (options.prompt) {
+        args.push(options.prompt);
+      }
+      
+      return args;
+    },
+    checkAvailable: () => {
+      try {
+        execSync('which gh', { stdio: 'ignore' });
+        return true;
+      } catch {
+        return false;
+      }
+    }
+  },
+  
+  'claude': {
+    command: 'claude',
+    args: (agent, options = {}) => {
+      const args = [];
+      
+      // Agent specification
+      if (agent) {
+        args.push('--agent', agent);
+      }
+      
+      // Model selection
+      if (options.model) {
+        args.push('--model', options.model);
+      }
+      
+      // System prompt for context (before positional prompt)
+      if (options.systemPrompt) {
+        args.push('--system-prompt', options.systemPrompt);
+      }
+      
+      // MCP config if needed
+      if (options.mcpConfig) {
+        args.push('--mcp-config', options.mcpConfig);
+      }
+      
+      // Prompt as POSITIONAL argument (not --prompt)
+      // Must come AFTER all flags
+      if (options.prompt) {
+        args.push(options.prompt);
+      }
+      
+      return args;
+    },
+    checkAvailable: () => {
+      try {
+        execSync('which claude', { stdio: 'ignore' });
+        return true;
+      } catch {
+        return false;
+      }
+    }
+  },
+  
+  'codex': {
+    command: 'codex',
+    args: (agent, options = {}) => {
+      const args = [];
+      
+      // Codex uses "skills" not "agents"
+      // Format: codex skill <skill-name> [prompt]
+      
+      if (agent) {
+        args.push('skill', `bmad-${agent}`);
+      }
+      
+      // Prompt as positional argument
+      if (options.prompt) {
+        args.push(options.prompt);
+      }
+      
+      // Model selection (if Codex supports it)
+      if (options.model) {
+        args.push('--model', options.model);
+      }
+      
+      return args;
+    },
+    checkAvailable: () => {
+      try {
+        execSync('which codex', { stdio: 'ignore' });
+        return true;
+      } catch {
+        return false;
+      }
+    }
+  }
+};
+
+/**
+ * Launch agent using native platform command
+ * 
+ * @param {LaunchOptions} options - Launch options
+ * @returns {Promise<LaunchResult>}
+ */
+async function launch(options) {
+  const { agent, platform, prompt, model, config } = options;
+  
+  const platformConfig = LAUNCH_CONFIGS[platform];
+  
+  if (!platformConfig) {
+    return {
+      success: false,
+      method: 'unsupported',
+      error: `Platform ${platform} not supported for native launch`
+    };
+  }
+  
+  // Check if platform command is available
+  if (!platformConfig.checkAvailable()) {
+    return {
+      success: false,
+      method: 'command-not-found',
+      error: `Command '${platformConfig.command}' not found in PATH`
+    };
+  }
+  
+  // Build command arguments
+  const args = platformConfig.args(agent, {
+    prompt,
+    model,
+    systemPrompt: config?.systemPrompt,
+    mcpConfig: config?.mcpConfig
+  });
+  
+  const fullCommand = `${platformConfig.command} ${args.join(' ')}`;
+  
+  logger.info(`Launching agent via: ${fullCommand}`);
+  
+  try {
+    // Launch in interactive mode (inherit stdio)
+    const result = spawn(platformConfig.command, args, {
+      stdio: 'inherit',
+      shell: true
+    });
+    
+    return new Promise((resolve) => {
+      result.on('close', (code) => {
+        if (code === 0) {
+          resolve({
+            success: true,
+            method: 'native-interactive',
+            output: `Agent launched successfully via ${platform}`
+          });
+        } else {
+          resolve({
+            success: false,
+            method: 'native-interactive',
+            error: `Agent exited with code ${code}`
+          });
+        }
+      });
+      
+      result.on('error', (error) => {
+        resolve({
+          success: false,
+          method: 'native-interactive',
+          error: error.message
+        });
+      });
+    });
+  } catch (error) {
+    return {
+      success: false,
+      method: 'native-interactive',
+      error: error.message
+    };
+  }
+}
+
+/**
+ * Launch agent with specific prompt (non-interactive)
+ * 
+ * Useful for automation or scripted workflows.
+ * 
+ * @param {LaunchOptions} options - Launch options
+ * @returns {Promise<LaunchResult>}
+ */
+async function launchWithPrompt(options) {
+  const { agent, platform, prompt, model, config } = options;
+  
+  if (!prompt) {
+    throw new Error('Prompt required for non-interactive launch');
+  }
+  
+  const platformConfig = LAUNCH_CONFIGS[platform];
+  
+  if (!platformConfig) {
+    return {
+      success: false,
+      method: 'unsupported',
+      error: `Platform ${platform} not supported`
+    };
+  }
+  
+  if (!platformConfig.checkAvailable()) {
+    return {
+      success: false,
+      method: 'command-not-found',
+      error: `Command '${platformConfig.command}' not found`
+    };
+  }
+  
+  const args = platformConfig.args(agent, {
+    prompt,
+    model,
+    systemPrompt: config?.systemPrompt
+  });
+  
+  // Add --print flag for Claude to get output
+  if (platform === 'claude') {
+    args.unshift('--print');
+  }
+  
+  const fullCommand = `${platformConfig.command} ${args.join(' ')}`;
+  
+  logger.info(`Executing: ${fullCommand}`);
+  
+  try {
+    const output = execSync(fullCommand, {
+      encoding: 'utf8',
+      maxBuffer: 10 * 1024 * 1024 // 10MB
+    });
+    
+    return {
+      success: true,
+      method: 'native-print',
+      output: output.trim()
+    };
+  } catch (error) {
+    return {
+      success: false,
+      method: 'native-print',
+      error: error.message
+    };
+  }
+}
+
+/**
+ * Generate launch instructions for manual invocation
+ * 
+ * Used as fallback when native launch isn't possible.
+ * 
+ * @param {LaunchOptions} options - Launch options
+ * @returns {string} - Human-readable instructions
+ */
+function getLaunchInstructions(options) {
+  const { agent, platform, prompt, model } = options;
+  
+  const platformConfig = LAUNCH_CONFIGS[platform];
+  
+  if (!platformConfig) {
+    return `Platform ${platform} not yet supported for automated launch.\nPlease activate the agent manually.`;
+  }
+  
+  const args = platformConfig.args(agent, { prompt, model });
+  const command = `${platformConfig.command} ${args.join(' ')}`;
+  
+  return `
+To activate the agent, run:
+
+  ${command}
+
+Or in interactive mode:
+  ${platformConfig.command}
+  Then: @bmad-agent-${agent}
+`;
+}
+
+/**
+ * Check if platform supports native agent launch
+ * 
+ * @param {string} platform - Platform ID
+ * @returns {boolean}
+ */
+function supportsNativeLaunch(platform) {
+  const config = LAUNCH_CONFIGS[platform];
+  if (!config) return false;
+  return config.checkAvailable();
+}
+
+/**
+ * Get available platforms for native launch
+ * 
+ * @returns {string[]} - List of platform IDs
+ */
+function getAvailablePlatforms() {
+  return Object.keys(LAUNCH_CONFIGS).filter(platform => {
+    const config = LAUNCH_CONFIGS[platform];
+    return config.checkAvailable();
+  });
+}
+
+module.exports = {
+  launch,
+  launchWithPrompt,
+  getLaunchInstructions,
+  supportsNativeLaunch,
+  getAvailablePlatforms
+};

package/install/lib/yanstaller/index.js

@@ -14,12 +14,14 @@ const troubleshooter = require('./troubleshooter');
 const interviewer = require('./interviewer');
 const backuper = require('./backuper');
 const wizard = require('./wizard');
+const platformSelector = require('./platform-selector');
 const logger = require('../utils/logger');
 
 /**
  * @typedef {Object} YanInstallerOptions
  * @property {boolean} [yes] - Skip confirmations (--yes flag)
  * @property {string} [mode] - Installation mode: 'full' | 'minimal' | 'custom'
+ * @property {string[]} [platforms] - Target platforms (override detection)
  * @property {boolean} [verbose] - Verbose output
  * @property {boolean} [quiet] - Minimal output
  */
@@ -34,16 +36,57 @@ async function install(options = {}) {
   let backupPath = null;
   
   try {
-    // TODO: Implement Phase 1-8 orchestration
-    // 1. Detect environment
-    // 2. Validate Node version (FAIL FAST)
-    // 3. Recommend configuration
-    // 4. Run interview (unless --yes)
-    // 5. Backup existing installation
+    // Phase 1: Detect environment
+    logger.info('🔍 Detecting environment...');
+    const detection = await detector.detect();
+    
+    // Phase 2: Validate Node version (FAIL FAST)
+    if (!detector.isNodeVersionValid(detection.nodeVersion, '18.0.0')) {
+      throw new Error(`Node.js >= 18.0.0 required. Found: ${detection.nodeVersion}`);
+    }
+    
+    // Phase 3: Platform Selection
+    let platformSelection;
+    if (options.platforms) {
+      // CLI override
+      platformSelection = {
+        platforms: options.platforms,
+        mode: 'manual'
+      };
+    } else if (options.yes) {
+      // Auto mode
+      platformSelection = {
+        platforms: detection.platforms.filter(p => p.detected).map(p => p.name),
+        mode: 'auto'
+      };
+    } else {
+      // Interactive selection
+      platformSelection = await platformSelector.select(detection);
+    }
+    
+    logger.info(`\n✓ Selected ${platformSelection.platforms.length} platform(s)`);
+    logger.info(`  Mode: ${platformSelection.mode}`);
+    if (platformSelection.specialist) {
+      logger.info(`  Specialist: @bmad-agent-${platformSelection.specialist}`);
+    }
+    
+    // Phase 4: Recommend configuration
+    // TODO: Implement
+    
+    // Phase 5: Run interview (unless --yes)
+    // TODO: Implement
+    
+    // Phase 6: Backup existing installation
     // backupPath = await backuper.backup('_bmad');
-    // 6. Install agents
-    // 7. Validate installation
-    // 8. Show post-install wizard
+    
+    // Phase 7: Install agents
+    // TODO: Implement
+    
+    // Phase 8: Validate installation
+    // TODO: Implement
+    
+    // Phase 9: Show post-install wizard
+    // TODO: Implement
   } catch (error) {
     // ROLLBACK STRATEGY: Leave partial state + clear message
     // Rationale (Mantra #37 Ockham's Razor):
@@ -89,5 +132,8 @@ async function update(version) {
 module.exports = {
   install,
   uninstall,
-  update
+  update,
+  // Expose for testing
+  detector,
+  platformSelector
 };