whiteport-design-studio 0.2.2 → 0.3.0

package/tools/cli/lib/installer.js

@@ -10,7 +10,6 @@ const ora = require('ora');
 const yaml = require('js-yaml');
 const inquirer = require('inquirer').default || require('inquirer');
 const { compileAgentFile } = require('./compiler');
-const { writeIdeConfig } = require('./ide-configs');
 
 class Installer {
   constructor() {
@@ -25,50 +24,61 @@ class Installer {
    * @param {Object} config - Configuration from UI prompts
    */
   async install(config) {
-    const { projectDir, wdsFolder, ides, project_type, design_experience } = config;
+    const { projectDir, wdsFolder, root_folder } = config;
     const wdsDir = path.join(projectDir, wdsFolder);
-
-    // Check if already installed
-    if (await fs.pathExists(wdsDir)) {
-      console.log(chalk.yellow(`\n  ${wdsFolder}/ already exists.`));
-      const { action } = await inquirer.prompt([
-        {
-          type: 'list',
-          name: 'action',
-          message: 'What would you like to do?',
-          choices: [
-            { name: 'Update - Replace WDS files, keep config.yaml', value: 'update' },
-            { name: 'Fresh install - Remove everything and start over', value: 'fresh' },
-            { name: 'Cancel', value: 'cancel' },
-          ],
-        },
-      ]);
-
-      if (action === 'cancel') {
-        return { success: false };
+    const detection = config._detection || { type: 'fresh' };
+    const action = config._action || 'fresh';
+
+    // Handle legacy _wds/ → _bmad/wds/ migration
+    if (detection.type === 'legacy' && wdsFolder !== '_wds') {
+      const legacyDir = path.join(projectDir, '_wds');
+      const legacyConfigPath = path.join(legacyDir, 'config.yaml');
+
+      // Save config from legacy location
+      if (await fs.pathExists(legacyConfigPath)) {
+        let savedConfig = await fs.readFile(legacyConfigPath, 'utf8');
+        // Update wds_folder in saved config to new path
+        savedConfig = savedConfig.replace(/wds_folder:.*/, `wds_folder: ${wdsFolder}`);
+        config._savedConfigYaml = savedConfig;
       }
 
-      if (action === 'fresh') {
-        const removeSpinner = ora('Removing existing WDS installation...').start();
-        await fs.remove(wdsDir);
-        removeSpinner.succeed('Old installation removed');
-      } else if (action === 'update') {
-        // Preserve config.yaml during update
-        const configPath = path.join(wdsDir, 'config.yaml');
-        let savedConfig = null;
-        if (await fs.pathExists(configPath)) {
-          savedConfig = await fs.readFile(configPath, 'utf8');
-        }
+      const migrateSpinner = ora(`Migrating _wds/ → ${wdsFolder}/...`).start();
+      await fs.ensureDir(path.dirname(wdsDir));
+      await fs.remove(legacyDir);
+      migrateSpinner.succeed(`Legacy _wds/ removed — installing fresh at ${wdsFolder}/`);
+    }
 
-        const removeSpinner = ora('Updating WDS files...').start();
-        await fs.remove(wdsDir);
-        removeSpinner.succeed('Old files cleared');
+    // Handle update vs fresh for existing target path
+    if (action === 'update' && (await fs.pathExists(wdsDir))) {
+      // Preserve config.yaml during update
+      const configPath = path.join(wdsDir, 'config.yaml');
+      if (!config._savedConfigYaml && (await fs.pathExists(configPath))) {
+        config._savedConfigYaml = await fs.readFile(configPath, 'utf8');
+      }
 
-        // Will be restored after copy
-        config._savedConfigYaml = savedConfig;
+      const removeSpinner = ora('Updating WDS files...').start();
+      await fs.remove(wdsDir);
+      removeSpinner.succeed('Old files cleared');
+    } else if (action === 'fresh' && (await fs.pathExists(wdsDir))) {
+      const removeSpinner = ora('Removing existing WDS installation...').start();
+      await fs.remove(wdsDir);
+      removeSpinner.succeed('Old installation removed');
+    }
+
+    // On update, extract ides and root_folder from saved config
+    if (action === 'update' && config._savedConfigYaml) {
+      try {
+        const savedData = yaml.load(config._savedConfigYaml);
+        if (!config.ides && savedData.ides) config.ides = savedData.ides;
+        if (!config.root_folder && savedData.output_folder) config.root_folder = savedData.output_folder;
+      } catch {
+        /* ignore parse errors, defaults will apply */
       }
     }
 
+    // Ensure parent directory exists (for _bmad/wds/)
+    await fs.ensureDir(path.dirname(wdsDir));
+
     console.log('');
 
     // Step 1: Copy source files
@@ -101,42 +111,51 @@ class Installer {
       throw error;
     }
 
-    // Step 4: Create docs folder structure
-    const docsSpinner = ora('Creating project folders...').start();
-    let detectedOutputFolder = 'docs';
-    try {
-      detectedOutputFolder = await this.createDocsFolders(projectDir, config);
-      docsSpinner.succeed(`Project folders created in ${detectedOutputFolder}/`);
-    } catch (error) {
-      docsSpinner.fail('Failed to create project folders');
-      throw error;
-    }
+    // Step 3.5: Setup IDE integrations
+    if (config.ides && config.ides.length > 0) {
+      const ideSpinner = ora('Setting up IDE integrations...').start();
+      try {
+        const { IdeManager } = require('../installers/lib/ide/manager');
+        const ideManager = new IdeManager();
 
-    // Update config.yaml with detected output folder (if different from default)
-    if (detectedOutputFolder !== 'docs') {
-      const configPath = path.join(wdsDir, 'config.yaml');
-      let configContent = await fs.readFile(configPath, 'utf8');
-      configContent = configContent.replace(/output_folder:\s*docs/, `output_folder: ${detectedOutputFolder}`);
-      await fs.writeFile(configPath, configContent, 'utf8');
+        const results = await ideManager.setup(projectDir, wdsDir, config.ides, {
+          logger: {
+            log: (msg) => {}, // Suppress detailed logs during spinner
+            warn: (msg) => console.log(msg),
+          },
+          wdsFolderName: wdsFolder,
+        });
+
+        const successCount = results.success.length;
+        const failedCount = results.failed.length;
+        const skippedCount = results.skipped.length;
+
+        if (successCount > 0) {
+          ideSpinner.succeed(`IDE integrations configured (${successCount} IDE${successCount > 1 ? 's' : ''})`);
+        } else if (failedCount > 0 || skippedCount > 0) {
+          ideSpinner.warn(`IDE setup completed with ${failedCount} failed, ${skippedCount} skipped`);
+        } else {
+          ideSpinner.succeed('IDE integrations configured');
+        }
+      } catch (error) {
+        ideSpinner.warn(`IDE setup encountered issues: ${error.message}`);
+        console.log(chalk.dim('  You can still use WDS by manually activating agents'));
+      }
     }
 
-    // Step 5: Set up IDEs
-    const ideList = ides || (config.ide ? [config.ide] : []);
-    const ideSpinner = ora(`Setting up ${ideList.length} IDE(s)...`).start();
+    // Step 4: Create work products folder structure
+    const rootFolder = root_folder || 'design-process';
+    const docsSpinner = ora(`Creating project folders in ${rootFolder}/...`).start();
     try {
-      const labels = [];
-      for (const ide of ideList) {
-        const result = await writeIdeConfig(projectDir, ide, wdsFolder);
-        labels.push(result.label);
-      }
-      ideSpinner.succeed(`Configured: ${labels.join(', ')}`);
+      await this.createDocsFolders(projectDir, rootFolder, config);
+      docsSpinner.succeed(`Project folders created in ${rootFolder}/`);
     } catch (error) {
-      ideSpinner.fail('Failed to set up IDEs');
+      docsSpinner.fail('Failed to create project folders');
       throw error;
     }
 
-    // Step 6: Copy learning & reference material (optional)
-    if (config.include_learning) {
+    // Step 5: Copy learning & reference material (optional)
+    if (config.install_learning !== false) {
       const learnSpinner = ora('Copying learning & reference material...').start();
       try {
         await this.copyLearningMaterial(projectDir);
@@ -185,14 +204,26 @@ class Installer {
       return;
     }
 
+    // Get user name from git or system
+    const getUserName = () => {
+      try {
+        const { execSync } = require('node:child_process');
+        const gitName = execSync('git config user.name', { encoding: 'utf8' }).trim();
+        return gitName || 'Designer';
+      } catch {
+        return 'Designer';
+      }
+    };
+
     const configData = {
-      user_name: config.user_name || 'Designer',
-      communication_language: config.communication_language || 'en',
-      document_output_language: config.document_output_language || 'en',
-      output_folder: 'docs',
+      user_name: getUserName(),
+      project_name: config.project_name || 'Untitled Project',
+      starting_point: config.starting_point || 'brief',
+      communication_language: 'en',
+      document_output_language: 'en',
+      output_folder: config.root_folder || 'design-process',
       wds_folder: config.wdsFolder,
-      project_type: config.project_type,
-      design_experience: config.design_experience,
+      ides: config.ides || ['windsurf'],
     };
 
     const yamlStr = yaml.dump(configData, { lineWidth: -1 });
@@ -223,7 +254,7 @@ class Installer {
    */
   async copyLearningMaterial(projectDir) {
     const learnDir = path.join(projectDir, '_wds-learn');
-    const learningDirs = ['getting-started', 'learn-wds', 'method', 'models', 'tools'];
+    const learningDirs = ['getting-started', 'learn', 'method', 'models', 'tools'];
     const excludeDirs = new Set(['course-explainers', 'Webinars']);
 
     for (const dir of learningDirs) {
@@ -242,41 +273,16 @@ class Installer {
   }
 
   /**
-   * Create the WDS docs folder structure
-   * FIXED: Detects existing folders, doesn't overwrite files
+   * Create the WDS work products folder structure
+   * @param {string} projectDir - Project root directory
+   * @param {string} rootFolder - Root folder name (design-process)
+   * @param {Object} config - Configuration object
    */
-  async createDocsFolders(projectDir, config) {
-    // Check if user already has a deliverables folder with WDS content
-    const possibleFolders = ['design-process', 'docs', 'deliverables', 'wds-deliverables'];
-    let existingFolder = null;
-
-    for (const folderName of possibleFolders) {
-      const folderPath = path.join(projectDir, folderName);
-      if (await fs.pathExists(folderPath)) {
-        // Check if it has WDS structure (A-Product-Brief, B-Trigger-Map, etc.)
-        const hasProductBrief = await fs.pathExists(path.join(folderPath, 'A-Product-Brief'));
-        const hasTriggerMap = await fs.pathExists(path.join(folderPath, 'B-Trigger-Map'));
-        if (hasProductBrief || hasTriggerMap) {
-          existingFolder = folderName;
-          break;
-        }
-      }
-    }
+  async createDocsFolders(projectDir, rootFolder, config) {
+    const docsPath = path.join(projectDir, rootFolder);
 
-    // Use existing folder if found, otherwise default to 'docs'
-    const outputFolder = existingFolder || 'docs';
-    const docsPath = path.join(projectDir, outputFolder);
-
-    const folders = [
-      'A-Product-Brief',
-      'B-Trigger-Map',
-      'C-UX-Scenarios',
-      'D-Design-System',
-      'E-PRD',
-      'E-PRD/Design-Deliveries',
-      'F-Testing',
-      'G-Product-Development',
-    ];
+    // Simplified 4-phase structure
+    const folders = ['A-Product-Brief', 'B-Trigger-Map', 'C-UX-Scenarios', 'D-Design-System'];
 
     for (const folder of folders) {
       const folderPath = path.join(docsPath, folder);
@@ -294,107 +300,10 @@ class Installer {
       }
     }
 
-    // Create 00 guide files in each folder (if they don't exist)
-    await this.createFolderGuides(docsPath, config);
-
-    // Return the detected/used folder name so config.yaml can be updated
-    return outputFolder;
-  }
-
-  /**
-   * Create 00 guide files in each folder from templates
-   */
-  async createFolderGuides(docsPath, config) {
-    const templateDir = path.join(this.srcDir, 'workflows', '0-project-setup', 'templates', 'folder-guides');
-
-    // Mapping: template filename → destination folder & filename
-    const guides = [
-      { template: '00-product-brief.template.md', folder: 'A-Product-Brief', filename: '00-product-brief.md' },
-      { template: '00-trigger-map.template.md', folder: 'B-Trigger-Map', filename: '00-trigger-map.md' },
-      { template: '00-ux-scenarios.template.md', folder: 'C-UX-Scenarios', filename: '00-ux-scenarios.md' },
-      { template: '00-design-system.template.md', folder: 'D-Design-System', filename: '00-design-system.md' },
-    ];
-
-    // Common placeholder replacements
-    const replacements = {
-      '{{project_name}}': config.project_name || 'Untitled Project',
-      '{{date}}': new Date().toISOString().split('T')[0],
-      '{{project_type}}': config.project_type || 'digital_product',
-      '{{design_experience}}': config.design_experience || 'intermediate',
-      '{{user_name}}': config.user_name || 'Designer',
-      '{{communication_language}}': config.communication_language || 'en',
-      '{{document_output_language}}': config.document_output_language || 'en',
-      '{{output_folder}}': path.relative(config.projectDir, docsPath) || 'docs',
-      '{{wds_folder}}': config.wdsFolder || '_wds',
-    };
-
-    // Create each folder guide
-    for (const guide of guides) {
-      const templatePath = path.join(templateDir, guide.template);
-      const destPath = path.join(docsPath, guide.folder, guide.filename);
-
-      // Skip if file exists (never overwrite) or template doesn't exist
-      if (await fs.pathExists(destPath)) continue;
-      if (!(await fs.pathExists(templatePath))) continue;
-
-      // Read template
-      let content = await fs.readFile(templatePath, 'utf8');
-
-      // Replace all placeholders
-      for (const [placeholder, value] of Object.entries(replacements)) {
-        content = content.split(placeholder).join(value);
-      }
-
-      // Write file
-      await fs.writeFile(destPath, content, 'utf8');
-    }
-
-    // Also create 00-project-info.md in A-Product-Brief (project settings home)
-    await this.createProjectInfoFile(docsPath, config);
-  }
-
-  /**
-   * Create 00-project-info.md in A-Product-Brief from template
-   */
-  async createProjectInfoFile(docsPath, config) {
-    const productBriefPath = path.join(docsPath, 'A-Product-Brief');
-    const projectInfoPath = path.join(productBriefPath, '00-project-info.md');
-
-    // Only create if it doesn't exist (never overwrite)
-    if (await fs.pathExists(projectInfoPath)) {
-      return;
-    }
-
-    const templatePath = path.join(this.srcDir, 'workflows', '1-project-brief', 'templates', '00-project-info.template.md');
-
-    // Check if template exists
-    if (!(await fs.pathExists(templatePath))) {
-      // Skip if template not found (backward compatibility)
-      return;
-    }
-
-    // Read template
-    let template = await fs.readFile(templatePath, 'utf8');
-
-    // Replace placeholders
-    const replacements = {
-      '{{project_name}}': config.project_name || 'Untitled Project',
-      '{{date}}': new Date().toISOString().split('T')[0],
-      '{{project_type}}': config.project_type || 'digital_product',
-      '{{design_experience}}': config.design_experience || 'intermediate',
-      '{{user_name}}': config.user_name || 'Designer',
-      '{{communication_language}}': config.communication_language || 'en',
-      '{{document_output_language}}': config.document_output_language || 'en',
-      '{{output_folder}}': path.relative(config.projectDir, docsPath) || 'docs',
-      '{{wds_folder}}': config.wdsFolder || '_wds',
-    };
-
-    for (const [placeholder, value] of Object.entries(replacements)) {
-      template = template.split(placeholder).join(value);
-    }
-
-    // Write the file
-    await fs.writeFile(projectInfoPath, template, 'utf8');
+    // Create _progress folder for agent tracking
+    const progressPath = path.join(docsPath, '_progress');
+    await fs.ensureDir(progressPath);
+    await fs.ensureDir(path.join(progressPath, 'agent-experiences'));
   }
 }