bmad-method 6.0.0-alpha.0 → 6.0.0-alpha.2

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

@@ -1,37 +1,42 @@
 const path = require('node:path');
 const fs = require('fs-extra');
+const crypto = require('node:crypto');
 
 class Manifest {
   /**
    * Create a new manifest
    * @param {string} bmadDir - Path to bmad directory
    * @param {Object} data - Manifest data
-   * @param {Array} installedFiles - List of installed files to track
+   * @param {Array} installedFiles - List of installed files (no longer used, files tracked in files-manifest.csv)
    */
   async create(bmadDir, data, installedFiles = []) {
-    const manifestPath = path.join(bmadDir, '_cfg', 'manifest.csv');
+    const manifestPath = path.join(bmadDir, '_cfg', 'manifest.yaml');
+    const yaml = require('js-yaml');
 
     // Ensure _cfg directory exists
     await fs.ensureDir(path.dirname(manifestPath));
 
-    // Load module configs to get module metadata
-    // If core is installed, add it to modules list
-    const allModules = [...(data.modules || [])];
-    if (data.core) {
-      allModules.unshift('core'); // Add core at the beginning
-    }
-    const moduleConfigs = await this.loadModuleConfigs(allModules);
-
-    // Parse installed files to extract metadata - pass bmadDir for relative paths
-    const fileMetadata = await this.parseInstalledFiles(installedFiles, bmadDir);
-
-    // Don't store installation path in manifest
+    // Structure the manifest data
+    const manifestData = {
+      installation: {
+        version: data.version || require(path.join(process.cwd(), 'package.json')).version,
+        installDate: data.installDate || new Date().toISOString(),
+        lastUpdated: data.lastUpdated || new Date().toISOString(),
+      },
+      modules: data.modules || [],
+      ides: data.ides || [],
+    };
 
-    // Generate CSV content
-    const csvContent = this.generateManifestCsv({ ...data, modules: allModules }, fileMetadata, moduleConfigs);
+    // Write YAML manifest
+    const yamlContent = yaml.dump(manifestData, {
+      indent: 2,
+      lineWidth: -1,
+      noRefs: true,
+      sortKeys: false,
+    });
 
-    await fs.writeFile(manifestPath, csvContent, 'utf8');
-    return { success: true, path: manifestPath, filesTracked: fileMetadata.length };
+    await fs.writeFile(manifestPath, yamlContent, 'utf8');
+    return { success: true, path: manifestPath, filesTracked: 0 };
   }
 
   /**
@@ -40,14 +45,24 @@ class Manifest {
    * @returns {Object|null} Manifest data or null if not found
    */
   async read(bmadDir) {
-    const csvPath = path.join(bmadDir, '_cfg', 'manifest.csv');
+    const yamlPath = path.join(bmadDir, '_cfg', 'manifest.yaml');
+    const yaml = require('js-yaml');
 
-    if (await fs.pathExists(csvPath)) {
+    if (await fs.pathExists(yamlPath)) {
       try {
-        const content = await fs.readFile(csvPath, 'utf8');
-        return this.parseManifestCsv(content);
+        const content = await fs.readFile(yamlPath, 'utf8');
+        const manifestData = yaml.load(content);
+
+        // Flatten the structure for compatibility with existing code
+        return {
+          version: manifestData.installation?.version,
+          installDate: manifestData.installation?.installDate,
+          lastUpdated: manifestData.installation?.lastUpdated,
+          modules: manifestData.modules || [],
+          ides: manifestData.ides || [],
+        };
       } catch (error) {
-        console.error('Failed to read CSV manifest:', error.message);
+        console.error('Failed to read YAML manifest:', error.message);
       }
     }
 
@@ -61,25 +76,37 @@ class Manifest {
    * @param {Array} installedFiles - Updated list of installed files
    */
   async update(bmadDir, updates, installedFiles = null) {
+    const yaml = require('js-yaml');
     const manifest = (await this.read(bmadDir)) || {};
 
     // Merge updates
     Object.assign(manifest, updates);
     manifest.lastUpdated = new Date().toISOString();
 
-    // If new file list provided, reparse metadata
-    let fileMetadata = manifest.files || [];
-    if (installedFiles) {
-      fileMetadata = await this.parseInstalledFiles(installedFiles);
-    }
+    // Convert back to structured format for YAML
+    const manifestData = {
+      installation: {
+        version: manifest.version,
+        installDate: manifest.installDate,
+        lastUpdated: manifest.lastUpdated,
+      },
+      modules: manifest.modules || [],
+      ides: manifest.ides || [],
+    };
 
-    const manifestPath = path.join(bmadDir, '_cfg', 'manifest.csv');
+    const manifestPath = path.join(bmadDir, '_cfg', 'manifest.yaml');
     await fs.ensureDir(path.dirname(manifestPath));
 
-    const csvContent = this.generateManifestCsv({ ...manifest, ...updates }, fileMetadata);
-    await fs.writeFile(manifestPath, csvContent, 'utf8');
+    const yamlContent = yaml.dump(manifestData, {
+      indent: 2,
+      lineWidth: -1,
+      noRefs: true,
+      sortKeys: false,
+    });
+
+    await fs.writeFile(manifestPath, yamlContent, 'utf8');
 
-    return { ...manifest, ...updates, files: fileMetadata };
+    return manifest;
   }
 
   /**
@@ -142,6 +169,20 @@ class Manifest {
     }
   }
 
+  /**
+   * Calculate SHA256 hash of a file
+   * @param {string} filePath - Path to file
+   * @returns {string} SHA256 hash
+   */
+  async calculateFileHash(filePath) {
+    try {
+      const content = await fs.readFile(filePath);
+      return crypto.createHash('sha256').update(content).digest('hex');
+    } catch {
+      return null;
+    }
+  }
+
   /**
    * Parse installed files to extract metadata
    * @param {Array} installedFiles - List of installed file paths
@@ -156,7 +197,10 @@ class Manifest {
       // Make path relative to parent of bmad directory, starting with 'bmad/'
       const relativePath = 'bmad' + filePath.replace(bmadDir, '').replaceAll('\\', '/');
 
-      // Handle markdown files - extract XML metadata
+      // Calculate file hash
+      const hash = await this.calculateFileHash(filePath);
+
+      // Handle markdown files - extract XML metadata if present
       if (fileExt === '.md') {
         try {
           if (await fs.pathExists(filePath)) {
@@ -164,20 +208,32 @@ class Manifest {
             const metadata = this.extractXmlNodeAttributes(content, filePath, relativePath);
 
             if (metadata) {
+              // Has XML metadata
+              metadata.hash = hash;
               fileMetadata.push(metadata);
+            } else {
+              // No XML metadata - still track the file
+              fileMetadata.push({
+                file: relativePath,
+                type: 'md',
+                name: path.basename(filePath, fileExt),
+                title: null,
+                hash: hash,
+              });
             }
           }
         } catch (error) {
           console.warn(`Warning: Could not parse ${filePath}:`, error.message);
         }
       }
-      // Handle other file types (CSV, JSON, etc.)
+      // Handle other file types (CSV, JSON, YAML, etc.)
       else {
         fileMetadata.push({
           file: relativePath,
           type: fileExt.slice(1), // Remove the dot
           name: path.basename(filePath, fileExt),
           title: null,
+          hash: hash,
         });
       }
     }
@@ -268,13 +324,8 @@ class Manifest {
       csv.push('');
     }
 
-    // Files section
-    if (fileMetadata.length > 0) {
-      csv.push('## Files', 'Type,Path,Name,Title');
-      for (const file of fileMetadata) {
-        csv.push([file.type || '', file.file || '', file.name || '', file.title || ''].map((v) => this.escapeCsv(v)).join(','));
-      }
-    }
+    // Files section - NO LONGER USED
+    // Files are now tracked in files-manifest.csv by ManifestGenerator
 
     return csv.join('\n');
   }
@@ -357,8 +408,8 @@ class Manifest {
           break;
         }
         case 'files': {
-          // Skip header row
-          if (line === 'Type,Path,Name,Title') continue;
+          // Skip header rows (support both old and new format)
+          if (line === 'Type,Path,Name,Title' || line === 'Type,Path,Name,Title,Hash') continue;
 
           const parts = this.parseCsvLine(line);
           if (parts.length >= 2) {
@@ -367,6 +418,7 @@ class Manifest {
               file: parts[1] || '',
               name: parts[2] || null,
               title: parts[3] || null,
+              hash: parts[4] || null, // Hash column (may not exist in old manifests)
             });
           }
 

package/tools/cli/installers/lib/ide/_base-ide.js

@@ -15,6 +15,8 @@ class BaseIdeSetup {
     this.preferred = preferred; // Whether this IDE should be shown in preferred list
     this.configDir = null; // Override in subclasses
     this.rulesDir = null; // Override in subclasses
+    this.configFile = null; // Override in subclasses when detection is file-based
+    this.detectionPaths = []; // Additional paths that indicate the IDE is configured
     this.xmlHandler = new XmlHandler();
   }
 
@@ -46,6 +48,40 @@ class BaseIdeSetup {
     }
   }
 
+  /**
+   * Detect whether this IDE already has configuration in the project
+   * Subclasses can override for custom logic
+   * @param {string} projectDir - Project directory
+   * @returns {boolean}
+   */
+  async detect(projectDir) {
+    const pathsToCheck = [];
+
+    if (this.configDir) {
+      pathsToCheck.push(path.join(projectDir, this.configDir));
+    }
+
+    if (this.configFile) {
+      pathsToCheck.push(path.join(projectDir, this.configFile));
+    }
+
+    if (Array.isArray(this.detectionPaths)) {
+      for (const candidate of this.detectionPaths) {
+        if (!candidate) continue;
+        const resolved = path.isAbsolute(candidate) ? candidate : path.join(projectDir, candidate);
+        pathsToCheck.push(resolved);
+      }
+    }
+
+    for (const candidate of pathsToCheck) {
+      if (await fs.pathExists(candidate)) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
   /**
    * Get list of agents from BMAD installation
    * @param {string} bmadDir - BMAD installation directory
@@ -69,7 +105,7 @@ class BaseIdeSetup {
     // Get module agents
     const entries = await fs.readdir(bmadDir, { withFileTypes: true });
     for (const entry of entries) {
-      if (entry.isDirectory() && entry.name !== 'core' && entry.name !== '_cfg') {
+      if (entry.isDirectory() && entry.name !== 'core' && entry.name !== '_cfg' && entry.name !== 'agents') {
         const moduleAgentsPath = path.join(bmadDir, entry.name, 'agents');
         if (await fs.pathExists(moduleAgentsPath)) {
           const moduleAgents = await this.scanDirectory(moduleAgentsPath, '.md');
@@ -83,21 +119,53 @@ class BaseIdeSetup {
       }
     }
 
+    // Get standalone agents from bmad/agents/ directory
+    const standaloneAgentsDir = path.join(bmadDir, 'agents');
+    if (await fs.pathExists(standaloneAgentsDir)) {
+      const agentDirs = await fs.readdir(standaloneAgentsDir, { withFileTypes: true });
+
+      for (const agentDir of agentDirs) {
+        if (!agentDir.isDirectory()) continue;
+
+        const agentDirPath = path.join(standaloneAgentsDir, agentDir.name);
+        const agentFiles = await fs.readdir(agentDirPath);
+
+        for (const file of agentFiles) {
+          if (!file.endsWith('.md')) continue;
+          if (file.includes('.customize.')) continue;
+
+          const filePath = path.join(agentDirPath, file);
+          const content = await fs.readFile(filePath, 'utf8');
+
+          if (content.includes('localskip="true"')) continue;
+
+          agents.push({
+            name: file.replace('.md', ''),
+            path: filePath,
+            relativePath: path.relative(standaloneAgentsDir, filePath),
+            filename: file,
+            module: 'standalone', // Mark as standalone agent
+          });
+        }
+      }
+    }
+
     return agents;
   }
 
   /**
    * Get list of tasks from BMAD installation
    * @param {string} bmadDir - BMAD installation directory
+   * @param {boolean} standaloneOnly - If true, only return standalone tasks
    * @returns {Array} List of task files
    */
-  async getTasks(bmadDir) {
+  async getTasks(bmadDir, standaloneOnly = false) {
     const tasks = [];
 
-    // Get core tasks
+    // Get core tasks (scan for both .md and .xml)
     const coreTasksPath = path.join(bmadDir, 'core', 'tasks');
     if (await fs.pathExists(coreTasksPath)) {
-      const coreTasks = await this.scanDirectory(coreTasksPath, '.md');
+      const coreTasks = await this.scanDirectoryWithStandalone(coreTasksPath, ['.md', '.xml']);
       tasks.push(
         ...coreTasks.map((t) => ({
           ...t,
@@ -109,10 +177,10 @@ class BaseIdeSetup {
     // Get module tasks
     const entries = await fs.readdir(bmadDir, { withFileTypes: true });
     for (const entry of entries) {
-      if (entry.isDirectory() && entry.name !== 'core' && entry.name !== '_cfg') {
+      if (entry.isDirectory() && entry.name !== 'core' && entry.name !== '_cfg' && entry.name !== 'agents') {
         const moduleTasksPath = path.join(bmadDir, entry.name, 'tasks');
         if (await fs.pathExists(moduleTasksPath)) {
-          const moduleTasks = await this.scanDirectory(moduleTasksPath, '.md');
+          const moduleTasks = await this.scanDirectoryWithStandalone(moduleTasksPath, ['.md', '.xml']);
           tasks.push(
             ...moduleTasks.map((t) => ({
               ...t,
@@ -123,13 +191,157 @@ class BaseIdeSetup {
       }
     }
 
+    // Filter by standalone if requested
+    if (standaloneOnly) {
+      return tasks.filter((t) => t.standalone === true);
+    }
+
     return tasks;
   }
 
   /**
-   * Scan a directory for files with specific extension
+   * Get list of tools from BMAD installation
+   * @param {string} bmadDir - BMAD installation directory
+   * @param {boolean} standaloneOnly - If true, only return standalone tools
+   * @returns {Array} List of tool files
+   */
+  async getTools(bmadDir, standaloneOnly = false) {
+    const tools = [];
+
+    // Get core tools (scan for both .md and .xml)
+    const coreToolsPath = path.join(bmadDir, 'core', 'tools');
+    if (await fs.pathExists(coreToolsPath)) {
+      const coreTools = await this.scanDirectoryWithStandalone(coreToolsPath, ['.md', '.xml']);
+      tools.push(
+        ...coreTools.map((t) => ({
+          ...t,
+          module: 'core',
+        })),
+      );
+    }
+
+    // Get module tools
+    const entries = await fs.readdir(bmadDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory() && entry.name !== 'core' && entry.name !== '_cfg' && entry.name !== 'agents') {
+        const moduleToolsPath = path.join(bmadDir, entry.name, 'tools');
+        if (await fs.pathExists(moduleToolsPath)) {
+          const moduleTools = await this.scanDirectoryWithStandalone(moduleToolsPath, ['.md', '.xml']);
+          tools.push(
+            ...moduleTools.map((t) => ({
+              ...t,
+              module: entry.name,
+            })),
+          );
+        }
+      }
+    }
+
+    // Filter by standalone if requested
+    if (standaloneOnly) {
+      return tools.filter((t) => t.standalone === true);
+    }
+
+    return tools;
+  }
+
+  /**
+   * Get list of workflows from BMAD installation
+   * @param {string} bmadDir - BMAD installation directory
+   * @param {boolean} standaloneOnly - If true, only return standalone workflows
+   * @returns {Array} List of workflow files
+   */
+  async getWorkflows(bmadDir, standaloneOnly = false) {
+    const workflows = [];
+
+    // Get core workflows
+    const coreWorkflowsPath = path.join(bmadDir, 'core', 'workflows');
+    if (await fs.pathExists(coreWorkflowsPath)) {
+      const coreWorkflows = await this.findWorkflowYamlFiles(coreWorkflowsPath);
+      workflows.push(
+        ...coreWorkflows.map((w) => ({
+          ...w,
+          module: 'core',
+        })),
+      );
+    }
+
+    // Get module workflows
+    const entries = await fs.readdir(bmadDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory() && entry.name !== 'core' && entry.name !== '_cfg' && entry.name !== 'agents') {
+        const moduleWorkflowsPath = path.join(bmadDir, entry.name, 'workflows');
+        if (await fs.pathExists(moduleWorkflowsPath)) {
+          const moduleWorkflows = await this.findWorkflowYamlFiles(moduleWorkflowsPath);
+          workflows.push(
+            ...moduleWorkflows.map((w) => ({
+              ...w,
+              module: entry.name,
+            })),
+          );
+        }
+      }
+    }
+
+    // Filter by standalone if requested
+    if (standaloneOnly) {
+      return workflows.filter((w) => w.standalone === true);
+    }
+
+    return workflows;
+  }
+
+  /**
+   * Recursively find workflow.yaml files
+   * @param {string} dir - Directory to search
+   * @returns {Array} List of workflow file info objects
+   */
+  async findWorkflowYamlFiles(dir) {
+    const workflows = [];
+
+    if (!(await fs.pathExists(dir))) {
+      return workflows;
+    }
+
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+
+      if (entry.isDirectory()) {
+        // Recursively search subdirectories
+        const subWorkflows = await this.findWorkflowYamlFiles(fullPath);
+        workflows.push(...subWorkflows);
+      } else if (entry.isFile() && entry.name === 'workflow.yaml') {
+        // Read workflow.yaml to get name and standalone property
+        try {
+          const yaml = require('js-yaml');
+          const content = await fs.readFile(fullPath, 'utf8');
+          const workflowData = yaml.load(content);
+
+          if (workflowData && workflowData.name) {
+            workflows.push({
+              name: workflowData.name,
+              path: fullPath,
+              relativePath: path.relative(dir, fullPath),
+              filename: entry.name,
+              description: workflowData.description || '',
+              standalone: workflowData.standalone === true, // Check standalone property
+            });
+          }
+        } catch {
+          // Skip invalid workflow files
+        }
+      }
+    }
+
+    return workflows;
+  }
+
+  /**
+   * Scan a directory for files with specific extension(s)
    * @param {string} dir - Directory to scan
-   * @param {string} ext - File extension to match
+   * @param {string|Array<string>} ext - File extension(s) to match (e.g., '.md' or ['.md', '.xml'])
    * @returns {Array} List of file info objects
    */
   async scanDirectory(dir, ext) {
@@ -139,6 +351,9 @@ class BaseIdeSetup {
       return files;
     }
 
+    // Normalize ext to array
+    const extensions = Array.isArray(ext) ? ext : [ext];
+
     const entries = await fs.readdir(dir, { withFileTypes: true });
 
     for (const entry of entries) {
@@ -148,13 +363,88 @@ class BaseIdeSetup {
         // Recursively scan subdirectories
         const subFiles = await this.scanDirectory(fullPath, ext);
         files.push(...subFiles);
-      } else if (entry.isFile() && entry.name.endsWith(ext)) {
-        files.push({
-          name: path.basename(entry.name, ext),
-          path: fullPath,
-          relativePath: path.relative(dir, fullPath),
-          filename: entry.name,
-        });
+      } else if (entry.isFile()) {
+        // Check if file matches any of the extensions
+        const matchedExt = extensions.find((e) => entry.name.endsWith(e));
+        if (matchedExt) {
+          files.push({
+            name: path.basename(entry.name, matchedExt),
+            path: fullPath,
+            relativePath: path.relative(dir, fullPath),
+            filename: entry.name,
+          });
+        }
+      }
+    }
+
+    return files;
+  }
+
+  /**
+   * Scan a directory for files with specific extension(s) and check standalone attribute
+   * @param {string} dir - Directory to scan
+   * @param {string|Array<string>} ext - File extension(s) to match (e.g., '.md' or ['.md', '.xml'])
+   * @returns {Array} List of file info objects with standalone property
+   */
+  async scanDirectoryWithStandalone(dir, ext) {
+    const files = [];
+
+    if (!(await fs.pathExists(dir))) {
+      return files;
+    }
+
+    // Normalize ext to array
+    const extensions = Array.isArray(ext) ? ext : [ext];
+
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+
+      if (entry.isDirectory()) {
+        // Recursively scan subdirectories
+        const subFiles = await this.scanDirectoryWithStandalone(fullPath, ext);
+        files.push(...subFiles);
+      } else if (entry.isFile()) {
+        // Check if file matches any of the extensions
+        const matchedExt = extensions.find((e) => entry.name.endsWith(e));
+        if (matchedExt) {
+          // Read file content to check for standalone attribute
+          let standalone = false;
+          try {
+            const content = await fs.readFile(fullPath, 'utf8');
+
+            // Check for standalone="true" in XML files
+            if (entry.name.endsWith('.xml')) {
+              // Look for standalone="true" in the opening tag (task or tool)
+              const standaloneMatch = content.match(/<(?:task|tool)[^>]+standalone="true"/);
+              standalone = !!standaloneMatch;
+            } else if (entry.name.endsWith('.md')) {
+              // Check for standalone: true in YAML frontmatter
+              const frontmatterMatch = content.match(/^---\s*\n([\s\S]*?)\n---/);
+              if (frontmatterMatch) {
+                const yaml = require('js-yaml');
+                try {
+                  const frontmatter = yaml.load(frontmatterMatch[1]);
+                  standalone = frontmatter.standalone === true;
+                } catch {
+                  // Ignore YAML parse errors
+                }
+              }
+            }
+          } catch {
+            // If we can't read the file, assume not standalone
+            standalone = false;
+          }
+
+          files.push({
+            name: path.basename(entry.name, matchedExt),
+            path: fullPath,
+            relativePath: path.relative(dir, fullPath),
+            filename: entry.name,
+            standalone: standalone,
+          });
+        }
       }
     }
 
@@ -177,11 +467,12 @@ class BaseIdeSetup {
       processed = this.xmlHandler.injectActivationSimple(processed, metadata);
     }
 
-    // Use the actual project directory path if provided, otherwise default to 'bmad/'
-    const projectRoot = projectDir ? projectDir + '/' : 'bmad/';
-
-    // Common replacements (including in the activation block)
-    processed = processed.replaceAll('{project-root}', projectRoot);
+    // Only replace {project-root} if a specific projectDir is provided
+    // Otherwise leave the placeholder intact
+    // Note: Don't add trailing slash - paths in source include leading slash
+    if (projectDir) {
+      processed = processed.replaceAll('{project-root}', projectDir);
+    }
     processed = processed.replaceAll('{module}', metadata.module || 'core');
     processed = processed.replaceAll('{agent}', metadata.name || '');
     processed = processed.replaceAll('{task}', metadata.name || '');