bmad-method 6.0.0-alpha.14 → 6.0.0-alpha.15

package/tools/cli/installers/lib/core/manifest-generator.js

@@ -41,7 +41,11 @@ class ManifestGenerator {
     // Deduplicate modules list to prevent duplicates
     this.modules = [...new Set(['core', ...selectedModules, ...preservedModules, ...installedModules])];
     this.updatedModules = [...new Set(['core', ...selectedModules, ...installedModules])]; // All installed modules get rescanned
-    this.preservedModules = preservedModules; // These stay as-is in CSVs
+
+    // For CSV manifests, we need to include ALL modules that are installed
+    // preservedModules controls which modules stay as-is in the CSV (don't get rescanned)
+    // But all modules should be included in the final manifest
+    this.preservedModules = [...new Set([...preservedModules, ...selectedModules, ...installedModules])]; // Include all installed modules
     this.bmadDir = bmadDir;
     this.bmadFolderName = path.basename(bmadDir); // Get the actual folder name (e.g., '.bmad' or 'bmad')
     this.allInstalledFiles = installedFiles;
@@ -61,14 +65,14 @@ class ManifestGenerator {
     // Collect workflow data
     await this.collectWorkflows(selectedModules);
 
-    // Collect agent data
-    await this.collectAgents(selectedModules);
+    // Collect agent data - use updatedModules which includes all installed modules
+    await this.collectAgents(this.updatedModules);
 
     // Collect task data
-    await this.collectTasks(selectedModules);
+    await this.collectTasks(this.updatedModules);
 
     // Collect tool data
-    await this.collectTools(selectedModules);
+    await this.collectTools(this.updatedModules);
 
     // Write manifest files and collect their paths
     const manifestFiles = [
@@ -450,6 +454,21 @@ class ManifestGenerator {
   async writeMainManifest(cfgDir) {
     const manifestPath = path.join(cfgDir, 'manifest.yaml');
 
+    // Read existing manifest to preserve custom modules
+    let existingCustomModules = [];
+    if (await fs.pathExists(manifestPath)) {
+      try {
+        const existingContent = await fs.readFile(manifestPath, 'utf8');
+        const existingManifest = yaml.load(existingContent);
+        if (existingManifest && existingManifest.customModules) {
+          existingCustomModules = existingManifest.customModules;
+        }
+      } catch {
+        // If we can't read the existing manifest, continue without preserving custom modules
+        console.warn('Warning: Could not read existing manifest to preserve custom modules');
+      }
+    }
+
     const manifest = {
       installation: {
         version: packageJson.version,
@@ -457,6 +476,7 @@ class ManifestGenerator {
         lastUpdated: new Date().toISOString(),
       },
       modules: this.modules,
+      customModules: existingCustomModules, // Preserve custom modules
       ides: this.selectedIdes,
     };
 
@@ -562,12 +582,47 @@ class ManifestGenerator {
   async writeWorkflowManifest(cfgDir) {
     const csvPath = path.join(cfgDir, 'workflow-manifest.csv');
 
+    // Read existing manifest to preserve entries
+    const existingEntries = new Map();
+    if (await fs.pathExists(csvPath)) {
+      const content = await fs.readFile(csvPath, 'utf8');
+      const lines = content.split('\n').filter((line) => line.trim());
+
+      // Skip header
+      for (let i = 1; i < lines.length; i++) {
+        const line = lines[i];
+        if (line) {
+          // Parse CSV (simple parsing assuming no commas in quoted fields)
+          const parts = line.split('","');
+          if (parts.length >= 4) {
+            const name = parts[0].replace(/^"/, '');
+            const module = parts[2];
+            existingEntries.set(`${module}:${name}`, line);
+          }
+        }
+      }
+    }
+
     // Create CSV header - removed standalone column as ALL workflows now generate commands
     let csv = 'name,description,module,path\n';
 
-    // Add all workflows - no standalone property needed anymore
+    // Combine existing and new workflows
+    const allWorkflows = new Map();
+
+    // Add existing entries
+    for (const [key, value] of existingEntries) {
+      allWorkflows.set(key, value);
+    }
+
+    // Add/update new workflows
     for (const workflow of this.workflows) {
-      csv += `"${workflow.name}","${workflow.description}","${workflow.module}","${workflow.path}"\n`;
+      const key = `${workflow.module}:${workflow.name}`;
+      allWorkflows.set(key, `"${workflow.name}","${workflow.description}","${workflow.module}","${workflow.path}"`);
+    }
+
+    // Write all workflows
+    for (const [, value] of allWorkflows) {
+      csv += value + '\n';
     }
 
     await fs.writeFile(csvPath, csv);
@@ -581,12 +636,50 @@ class ManifestGenerator {
   async writeAgentManifest(cfgDir) {
     const csvPath = path.join(cfgDir, 'agent-manifest.csv');
 
+    // Read existing manifest to preserve entries
+    const existingEntries = new Map();
+    if (await fs.pathExists(csvPath)) {
+      const content = await fs.readFile(csvPath, 'utf8');
+      const lines = content.split('\n').filter((line) => line.trim());
+
+      // Skip header
+      for (let i = 1; i < lines.length; i++) {
+        const line = lines[i];
+        if (line) {
+          // Parse CSV (simple parsing assuming no commas in quoted fields)
+          const parts = line.split('","');
+          if (parts.length >= 11) {
+            const name = parts[0].replace(/^"/, '');
+            const module = parts[8];
+            existingEntries.set(`${module}:${name}`, line);
+          }
+        }
+      }
+    }
+
     // Create CSV header with persona fields
     let csv = 'name,displayName,title,icon,role,identity,communicationStyle,principles,module,path\n';
 
-    // Add all agents
+    // Combine existing and new agents, preferring new data for duplicates
+    const allAgents = new Map();
+
+    // Add existing entries
+    for (const [key, value] of existingEntries) {
+      allAgents.set(key, value);
+    }
+
+    // Add/update new agents
     for (const agent of this.agents) {
-      csv += `"${agent.name}","${agent.displayName}","${agent.title}","${agent.icon}","${agent.role}","${agent.identity}","${agent.communicationStyle}","${agent.principles}","${agent.module}","${agent.path}"\n`;
+      const key = `${agent.module}:${agent.name}`;
+      allAgents.set(
+        key,
+        `"${agent.name}","${agent.displayName}","${agent.title}","${agent.icon}","${agent.role}","${agent.identity}","${agent.communicationStyle}","${agent.principles}","${agent.module}","${agent.path}"`,
+      );
+    }
+
+    // Write all agents
+    for (const [, value] of allAgents) {
+      csv += value + '\n';
     }
 
     await fs.writeFile(csvPath, csv);
@@ -600,12 +693,47 @@ class ManifestGenerator {
   async writeTaskManifest(cfgDir) {
     const csvPath = path.join(cfgDir, 'task-manifest.csv');
 
+    // Read existing manifest to preserve entries
+    const existingEntries = new Map();
+    if (await fs.pathExists(csvPath)) {
+      const content = await fs.readFile(csvPath, 'utf8');
+      const lines = content.split('\n').filter((line) => line.trim());
+
+      // Skip header
+      for (let i = 1; i < lines.length; i++) {
+        const line = lines[i];
+        if (line) {
+          // Parse CSV (simple parsing assuming no commas in quoted fields)
+          const parts = line.split('","');
+          if (parts.length >= 6) {
+            const name = parts[0].replace(/^"/, '');
+            const module = parts[3];
+            existingEntries.set(`${module}:${name}`, line);
+          }
+        }
+      }
+    }
+
     // Create CSV header with standalone column
     let csv = 'name,displayName,description,module,path,standalone\n';
 
-    // Add all tasks
+    // Combine existing and new tasks
+    const allTasks = new Map();
+
+    // Add existing entries
+    for (const [key, value] of existingEntries) {
+      allTasks.set(key, value);
+    }
+
+    // Add/update new tasks
     for (const task of this.tasks) {
-      csv += `"${task.name}","${task.displayName}","${task.description}","${task.module}","${task.path}","${task.standalone}"\n`;
+      const key = `${task.module}:${task.name}`;
+      allTasks.set(key, `"${task.name}","${task.displayName}","${task.description}","${task.module}","${task.path}","${task.standalone}"`);
+    }
+
+    // Write all tasks
+    for (const [, value] of allTasks) {
+      csv += value + '\n';
     }
 
     await fs.writeFile(csvPath, csv);
@@ -619,12 +747,47 @@ class ManifestGenerator {
   async writeToolManifest(cfgDir) {
     const csvPath = path.join(cfgDir, 'tool-manifest.csv');
 
+    // Read existing manifest to preserve entries
+    const existingEntries = new Map();
+    if (await fs.pathExists(csvPath)) {
+      const content = await fs.readFile(csvPath, 'utf8');
+      const lines = content.split('\n').filter((line) => line.trim());
+
+      // Skip header
+      for (let i = 1; i < lines.length; i++) {
+        const line = lines[i];
+        if (line) {
+          // Parse CSV (simple parsing assuming no commas in quoted fields)
+          const parts = line.split('","');
+          if (parts.length >= 6) {
+            const name = parts[0].replace(/^"/, '');
+            const module = parts[3];
+            existingEntries.set(`${module}:${name}`, line);
+          }
+        }
+      }
+    }
+
     // Create CSV header with standalone column
     let csv = 'name,displayName,description,module,path,standalone\n';
 
-    // Add all tools
+    // Combine existing and new tools
+    const allTools = new Map();
+
+    // Add existing entries
+    for (const [key, value] of existingEntries) {
+      allTools.set(key, value);
+    }
+
+    // Add/update new tools
     for (const tool of this.tools) {
-      csv += `"${tool.name}","${tool.displayName}","${tool.description}","${tool.module}","${tool.path}","${tool.standalone}"\n`;
+      const key = `${tool.module}:${tool.name}`;
+      allTools.set(key, `"${tool.name}","${tool.displayName}","${tool.description}","${tool.module}","${tool.path}","${tool.standalone}"`);
+    }
+
+    // Write all tools
+    for (const [, value] of allTools) {
+      csv += value + '\n';
     }
 
     await fs.writeFile(csvPath, csv);

package/tools/cli/installers/lib/core/manifest.js

@@ -61,6 +61,7 @@ class Manifest {
           installDate: manifestData.installation?.installDate,
           lastUpdated: manifestData.installation?.lastUpdated,
           modules: manifestData.modules || [],
+          customModules: manifestData.customModules || [],
           ides: manifestData.ides || [],
         };
       } catch (error) {
@@ -93,6 +94,7 @@ class Manifest {
         lastUpdated: manifest.lastUpdated,
       },
       modules: manifest.modules || [],
+      customModules: manifest.customModules || [],
       ides: manifest.ides || [],
     };
 
@@ -535,6 +537,51 @@ class Manifest {
 
     return configs;
   }
+  /**
+   * Add a custom module to the manifest with its source path
+   * @param {string} bmadDir - Path to bmad directory
+   * @param {Object} customModule - Custom module info
+   */
+  async addCustomModule(bmadDir, customModule) {
+    const manifest = await this.read(bmadDir);
+    if (!manifest) {
+      throw new Error('No manifest found');
+    }
+
+    if (!manifest.customModules) {
+      manifest.customModules = [];
+    }
+
+    // Check if custom module already exists
+    const existingIndex = manifest.customModules.findIndex((m) => m.id === customModule.id);
+    if (existingIndex === -1) {
+      // Add new entry
+      manifest.customModules.push(customModule);
+    } else {
+      // Update existing entry
+      manifest.customModules[existingIndex] = customModule;
+    }
+
+    await this.update(bmadDir, { customModules: manifest.customModules });
+  }
+
+  /**
+   * Remove a custom module from the manifest
+   * @param {string} bmadDir - Path to bmad directory
+   * @param {string} moduleId - Module ID to remove
+   */
+  async removeCustomModule(bmadDir, moduleId) {
+    const manifest = await this.read(bmadDir);
+    if (!manifest || !manifest.customModules) {
+      return;
+    }
+
+    const index = manifest.customModules.findIndex((m) => m.id === moduleId);
+    if (index !== -1) {
+      manifest.customModules.splice(index, 1);
+      await this.update(bmadDir, { customModules: manifest.customModules });
+    }
+  }
 }
 
 module.exports = { Manifest };

package/tools/cli/installers/lib/custom/handler.js

@@ -3,6 +3,7 @@ const fs = require('fs-extra');
 const chalk = require('chalk');
 const yaml = require('js-yaml');
 const { FileOps } = require('../../../lib/file-ops');
+const { XmlHandler } = require('../../../lib/xml-handler');
 
 /**
  * Handler for custom content (custom.yaml)
@@ -11,6 +12,7 @@ const { FileOps } = require('../../../lib/file-ops');
 class CustomHandler {
   constructor() {
     this.fileOps = new FileOps();
+    this.xmlHandler = new XmlHandler();
   }
 
   /**
@@ -52,6 +54,12 @@ class CustomHandler {
           } else if (entry.name === 'custom.yaml') {
             // Found a custom.yaml file
             customPaths.push(fullPath);
+          } else if (
+            entry.name === 'module.yaml' && // Check if this is a custom module (either in _module-installer or in root directory)
+            // Skip if it's in src/modules (those are standard modules)
+            !fullPath.includes(path.join('src', 'modules'))
+          ) {
+            customPaths.push(fullPath);
           }
         }
       } catch {
@@ -66,37 +74,44 @@ class CustomHandler {
   }
 
   /**
-   * Get custom content info from a custom.yaml file
-   * @param {string} customYamlPath - Path to custom.yaml file
+   * Get custom content info from a custom.yaml or module.yaml file
+   * @param {string} configPath - Path to config file
+   * @param {string} projectRoot - Project root directory for calculating relative paths
    * @returns {Object|null} Custom content info
    */
-  async getCustomInfo(customYamlPath) {
+  async getCustomInfo(configPath, projectRoot = null) {
     try {
-      const configContent = await fs.readFile(customYamlPath, 'utf8');
+      const configContent = await fs.readFile(configPath, 'utf8');
 
       // Try to parse YAML with error handling
       let config;
       try {
         config = yaml.load(configContent);
       } catch (parseError) {
-        console.warn(chalk.yellow(`Warning: YAML parse error in ${customYamlPath}:`, parseError.message));
+        console.warn(chalk.yellow(`Warning: YAML parse error in ${configPath}:`, parseError.message));
         return null;
       }
 
-      const customDir = path.dirname(customYamlPath);
-      const relativePath = path.relative(process.cwd(), customDir);
+      // Check if this is an module.yaml (module) or custom.yaml (custom content)
+      const isInstallConfig = configPath.endsWith('module.yaml');
+      const configDir = path.dirname(configPath);
+
+      // Use provided projectRoot or fall back to process.cwd()
+      const basePath = projectRoot || process.cwd();
+      const relativePath = path.relative(basePath, configDir);
 
       return {
-        id: config.code || path.basename(customDir),
-        name: config.name || `Custom: ${path.basename(customDir)}`,
-        description: config.description || 'Custom agents and workflows',
-        path: customDir,
+        id: config.code || 'unknown-code',
+        name: config.name,
+        description: config.description || '',
+        path: configDir,
         relativePath: relativePath,
         defaultSelected: config.default_selected === true,
         config: config,
+        isInstallConfig: isInstallConfig, // Track which type this is
       };
     } catch (error) {
-      console.warn(chalk.yellow(`Warning: Failed to read ${customYamlPath}:`, error.message));
+      console.warn(chalk.yellow(`Warning: Failed to read ${configPath}:`, error.message));
       return null;
     }
   }
@@ -128,10 +143,10 @@ class CustomHandler {
       await fs.ensureDir(bmadAgentsDir);
       await fs.ensureDir(bmadWorkflowsDir);
 
-      // Process agents - copy entire agents directory structure
+      // Process agents - compile and copy agents
       const agentsDir = path.join(customPath, 'agents');
       if (await fs.pathExists(agentsDir)) {
-        await this.copyDirectory(agentsDir, bmadAgentsDir, results, fileTrackingCallback, config);
+        await this.compileAndCopyAgents(agentsDir, bmadAgentsDir, bmadDir, config, fileTrackingCallback, results);
 
         // Count agent files
         const agentFiles = await this.findFilesRecursively(agentsDir, ['.agent.yaml', '.md']);
@@ -236,13 +251,20 @@ class CustomHandler {
             // Copy with placeholder replacement for text files
             const textExtensions = ['.md', '.yaml', '.yml', '.txt', '.json'];
             if (textExtensions.some((ext) => entry.name.endsWith(ext))) {
-              await this.fileOps.copyFile(sourcePath, targetPath, {
-                bmadFolder: config.bmad_folder || 'bmad',
-                userName: config.user_name || 'User',
-                communicationLanguage: config.communication_language || 'English',
-                outputFolder: config.output_folder || 'docs',
-              });
+              // Read source content
+              let content = await fs.readFile(sourcePath, 'utf8');
+
+              // Replace placeholders
+              content = content.replaceAll('{bmad_folder}', config.bmad_folder || 'bmad');
+              content = content.replaceAll('{user_name}', config.user_name || 'User');
+              content = content.replaceAll('{communication_language}', config.communication_language || 'English');
+              content = content.replaceAll('{output_folder}', config.output_folder || 'docs');
+
+              // Write to target
+              await fs.ensureDir(path.dirname(targetPath));
+              await fs.writeFile(targetPath, content, 'utf8');
             } else {
+              // Copy binary files as-is
               await fs.copy(sourcePath, targetPath);
             }
 
@@ -261,6 +283,114 @@ class CustomHandler {
       }
     }
   }
+
+  /**
+   * Compile .agent.yaml files to .md format and handle sidecars
+   * @param {string} sourceAgentsPath - Source agents directory
+   * @param {string} targetAgentsPath - Target agents directory
+   * @param {string} bmadDir - BMAD installation directory
+   * @param {Object} config - Configuration for placeholder replacement
+   * @param {Function} fileTrackingCallback - Optional callback to track installed files
+   * @param {Object} results - Results object to update
+   */
+  async compileAndCopyAgents(sourceAgentsPath, targetAgentsPath, bmadDir, config, fileTrackingCallback, results) {
+    // Get all .agent.yaml files recursively
+    const agentFiles = await this.findFilesRecursively(sourceAgentsPath, ['.agent.yaml']);
+
+    for (const agentFile of agentFiles) {
+      const relativePath = path.relative(sourceAgentsPath, agentFile);
+      const targetDir = path.join(targetAgentsPath, path.dirname(relativePath));
+
+      await fs.ensureDir(targetDir);
+
+      const agentName = path.basename(agentFile, '.agent.yaml');
+      const targetMdPath = path.join(targetDir, `${agentName}.md`);
+      // Use the actual bmadDir if available (for when installing to temp dir)
+      const actualBmadDir = config._bmadDir || bmadDir;
+      const customizePath = path.join(actualBmadDir, '_cfg', 'agents', `custom-${agentName}.customize.yaml`);
+
+      // Read and compile the YAML
+      try {
+        const yamlContent = await fs.readFile(agentFile, 'utf8');
+        const { compileAgent } = require('../../../lib/agent/compiler');
+
+        // Create customize template if it doesn't exist
+        if (!(await fs.pathExists(customizePath))) {
+          const { getSourcePath } = require('../../../lib/project-root');
+          const genericTemplatePath = getSourcePath('utility', 'templates', 'agent.customize.template.yaml');
+          if (await fs.pathExists(genericTemplatePath)) {
+            // Copy with placeholder replacement
+            let templateContent = await fs.readFile(genericTemplatePath, 'utf8');
+            templateContent = templateContent.replaceAll('{bmad_folder}', config.bmad_folder || 'bmad');
+            await fs.writeFile(customizePath, templateContent, 'utf8');
+            console.log(chalk.dim(`  Created customize: custom-${agentName}.customize.yaml`));
+          }
+        }
+
+        // Compile the agent
+        const { xml } = compileAgent(yamlContent, {}, agentName, relativePath, { config });
+
+        // Replace placeholders in the compiled content
+        let processedXml = xml;
+        processedXml = processedXml.replaceAll('{bmad_folder}', config.bmad_folder || 'bmad');
+        processedXml = processedXml.replaceAll('{user_name}', config.user_name || 'User');
+        processedXml = processedXml.replaceAll('{communication_language}', config.communication_language || 'English');
+        processedXml = processedXml.replaceAll('{output_folder}', config.output_folder || 'docs');
+
+        // Write the compiled MD file
+        await fs.writeFile(targetMdPath, processedXml, 'utf8');
+
+        // Check if agent has sidecar
+        let hasSidecar = false;
+        try {
+          const yamlLib = require('yaml');
+          const agentYaml = yamlLib.parse(yamlContent);
+          hasSidecar = agentYaml?.agent?.metadata?.hasSidecar === true;
+        } catch {
+          // Continue without sidecar processing
+        }
+
+        // Copy sidecar files if agent has hasSidecar flag
+        if (hasSidecar && config.agent_sidecar_folder) {
+          const { copyAgentSidecarFiles } = require('../../../lib/agent/installer');
+
+          // Resolve agent sidecar folder path
+          const projectDir = path.dirname(bmadDir);
+          const resolvedSidecarFolder = config.agent_sidecar_folder
+            .replaceAll('{project-root}', projectDir)
+            .replaceAll('{bmad_folder}', path.basename(bmadDir));
+
+          // Create sidecar directory for this agent
+          const agentSidecarDir = path.join(resolvedSidecarFolder, agentName);
+          await fs.ensureDir(agentSidecarDir);
+
+          // Copy sidecar files
+          const sidecarResult = copyAgentSidecarFiles(path.dirname(agentFile), agentSidecarDir, agentFile);
+
+          if (sidecarResult.copied.length > 0) {
+            console.log(chalk.dim(`    Copied ${sidecarResult.copied.length} sidecar file(s) to: ${agentSidecarDir}`));
+          }
+          if (sidecarResult.preserved.length > 0) {
+            console.log(chalk.dim(`    Preserved ${sidecarResult.preserved.length} existing sidecar file(s)`));
+          }
+        }
+
+        // Track the file
+        if (fileTrackingCallback) {
+          fileTrackingCallback(targetMdPath);
+        }
+
+        console.log(
+          chalk.dim(
+            `    Compiled agent: ${agentName} -> ${path.relative(targetAgentsPath, targetMdPath)}${hasSidecar ? ' (with sidecar)' : ''}`,
+          ),
+        );
+      } catch (error) {
+        console.warn(chalk.yellow(`    Failed to compile agent ${agentName}:`, error.message));
+        results.errors.push(`Failed to compile agent ${agentName}: ${error.message}`);
+      }
+    }
+  }
 }
 
 module.exports = { CustomHandler };