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

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

@@ -1,9 +1,12 @@
 const path = require('node:path');
 const fs = require('fs-extra');
-const yaml = require('js-yaml');
+const yaml = require('yaml');
 const crypto = require('node:crypto');
 const { getSourcePath, getModulePath } = require('../../../lib/project-root');
 
+// Load package.json for version info
+const packageJson = require('../../../../../package.json');
+
 /**
  * Generates manifest files for installed workflows, agents, and tasks
  */
@@ -20,21 +23,34 @@ class ManifestGenerator {
 
   /**
    * Generate all manifests for the installation
-   * @param {string} bmadDir - BMAD installation directory
+   * @param {string} bmadDir - _bmad
    * @param {Array} selectedModules - Selected modules for installation
    * @param {Array} installedFiles - All installed files (optional, for hash tracking)
    */
   async generateManifests(bmadDir, selectedModules, installedFiles = [], options = {}) {
-    // Create _cfg directory if it doesn't exist
-    const cfgDir = path.join(bmadDir, '_cfg');
+    // Create _config directory if it doesn't exist
+    const cfgDir = path.join(bmadDir, '_config');
     await fs.ensureDir(cfgDir);
 
     // Store modules list (all modules including preserved ones)
     const preservedModules = options.preservedModules || [];
-    this.modules = ['core', ...selectedModules, ...preservedModules];
-    this.updatedModules = ['core', ...selectedModules]; // Only these get rescanned
-    this.preservedModules = preservedModules; // These stay as-is in CSVs
+
+    // Scan the bmad directory to find all actually installed modules
+    const installedModules = await this.scanInstalledModules(bmadDir);
+
+    // Since custom modules are now installed the same way as regular modules,
+    // we don't need to exclude them from manifest generation
+    const allModules = [...new Set(['core', ...selectedModules, ...preservedModules, ...installedModules])];
+
+    this.modules = allModules;
+    this.updatedModules = allModules; // Include ALL modules (including custom) for scanning
+
+    // 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 = allModules; // Include ALL modules (including custom)
     this.bmadDir = bmadDir;
+    this.bmadFolderName = path.basename(bmadDir); // Get the actual folder name (e.g., '_bmad' or 'bmad')
     this.allInstalledFiles = installedFiles;
 
     if (!Object.prototype.hasOwnProperty.call(options, 'ides')) {
@@ -52,14 +68,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 = [
@@ -88,15 +104,8 @@ class ManifestGenerator {
   async collectWorkflows(selectedModules) {
     this.workflows = [];
 
-    // Get core workflows from installed bmad directory
-    const corePath = path.join(this.bmadDir, 'core');
-    if (await fs.pathExists(corePath)) {
-      const coreWorkflows = await this.getWorkflowsFromPath(corePath, 'core');
-      this.workflows.push(...coreWorkflows);
-    }
-
-    // Get module workflows from installed bmad directory
-    for (const moduleName of selectedModules) {
+    // Use updatedModules which already includes deduplicated 'core' + selectedModules
+    for (const moduleName of this.updatedModules) {
       const modulePath = path.join(this.bmadDir, moduleName);
 
       if (await fs.pathExists(modulePath)) {
@@ -107,7 +116,7 @@ class ManifestGenerator {
   }
 
   /**
-   * Recursively find and parse workflow.yaml files
+   * Recursively find and parse workflow.yaml and workflow.md files
    */
   async getWorkflowsFromPath(basePath, moduleName) {
     const workflows = [];
@@ -128,11 +137,23 @@ class ManifestGenerator {
           // Recurse into subdirectories
           const newRelativePath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
           await findWorkflows(fullPath, newRelativePath);
-        } else if (entry.name === 'workflow.yaml') {
-          // Parse workflow file
+        } else if (entry.name === 'workflow.yaml' || entry.name === 'workflow.md') {
+          // Parse workflow file (both YAML and MD formats)
           try {
             const content = await fs.readFile(fullPath, 'utf8');
-            const workflow = yaml.load(content);
+
+            let workflow;
+            if (entry.name === 'workflow.yaml') {
+              // Parse YAML workflow
+              workflow = yaml.parse(content);
+            } else {
+              // Parse MD workflow with YAML frontmatter
+              const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+              if (!frontmatterMatch) {
+                continue; // Skip MD files without frontmatter
+              }
+              workflow = yaml.parse(frontmatterMatch[1]);
+            }
 
             // Skip template workflows (those with placeholder values)
             if (workflow.name && workflow.name.includes('{') && workflow.name.includes('}')) {
@@ -143,18 +164,15 @@ class ManifestGenerator {
               // Build relative path for installation
               const installPath =
                 moduleName === 'core'
-                  ? `bmad/core/workflows/${relativePath}/workflow.yaml`
-                  : `bmad/${moduleName}/workflows/${relativePath}/workflow.yaml`;
-
-              // Check for standalone property (default: false)
-              const standalone = workflow.standalone === true;
+                  ? `${this.bmadFolderName}/core/workflows/${relativePath}/${entry.name}`
+                  : `${this.bmadFolderName}/${moduleName}/workflows/${relativePath}/${entry.name}`;
 
+              // ALL workflows now generate commands - no standalone property needed
               workflows.push({
                 name: workflow.name,
                 description: workflow.description.replaceAll('"', '""'), // Escape quotes for CSV
                 module: moduleName,
                 path: installPath,
-                standalone: standalone,
               });
 
               // Add to files list
@@ -183,15 +201,8 @@ class ManifestGenerator {
   async collectAgents(selectedModules) {
     this.agents = [];
 
-    // Get core agents from installed bmad directory
-    const coreAgentsPath = path.join(this.bmadDir, 'core', 'agents');
-    if (await fs.pathExists(coreAgentsPath)) {
-      const coreAgents = await this.getAgentsFromDir(coreAgentsPath, 'core');
-      this.agents.push(...coreAgents);
-    }
-
-    // Get module agents from installed bmad directory
-    for (const moduleName of selectedModules) {
+    // Use updatedModules which already includes deduplicated 'core' + selectedModules
+    for (const moduleName of this.updatedModules) {
       const agentsPath = path.join(this.bmadDir, moduleName, 'agents');
 
       if (await fs.pathExists(agentsPath)) {
@@ -216,18 +227,23 @@ class ManifestGenerator {
   }
 
   /**
-   * Get agents from a directory
+   * Get agents from a directory recursively
    * Only includes compiled .md files (not .agent.yaml source files)
    */
-  async getAgentsFromDir(dirPath, moduleName) {
+  async getAgentsFromDir(dirPath, moduleName, relativePath = '') {
     const agents = [];
-    const files = await fs.readdir(dirPath);
+    const entries = await fs.readdir(dirPath, { withFileTypes: true });
 
-    for (const file of files) {
-      // Only include .md files, skip .agent.yaml source files and README.md
-      if (file.endsWith('.md') && !file.endsWith('.agent.yaml') && file.toLowerCase() !== 'readme.md') {
-        const filePath = path.join(dirPath, file);
-        const content = await fs.readFile(filePath, 'utf8');
+    for (const entry of entries) {
+      const fullPath = path.join(dirPath, entry.name);
+
+      if (entry.isDirectory()) {
+        // Recurse into subdirectories
+        const newRelativePath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
+        const subDirAgents = await this.getAgentsFromDir(fullPath, moduleName, newRelativePath);
+        agents.push(...subDirAgents);
+      } else if (entry.name.endsWith('.md') && !entry.name.endsWith('.agent.yaml') && entry.name.toLowerCase() !== 'readme.md') {
+        const content = await fs.readFile(fullPath, 'utf8');
 
         // Skip files that don't contain <agent> tag (e.g., README files)
         if (!content.includes('<agent')) {
@@ -251,9 +267,13 @@ class ManifestGenerator {
         const principlesMatch = content.match(/<principles>([\s\S]*?)<\/principles>/);
 
         // Build relative path for installation
-        const installPath = moduleName === 'core' ? `bmad/core/agents/${file}` : `bmad/${moduleName}/agents/${file}`;
+        const fileRelativePath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
+        const installPath =
+          moduleName === 'core'
+            ? `${this.bmadFolderName}/core/agents/${fileRelativePath}`
+            : `${this.bmadFolderName}/${moduleName}/agents/${fileRelativePath}`;
 
-        const agentName = file.replace('.md', '');
+        const agentName = entry.name.replace('.md', '');
 
         // Helper function to clean and escape CSV content
         const cleanForCSV = (text) => {
@@ -297,15 +317,8 @@ class ManifestGenerator {
   async collectTasks(selectedModules) {
     this.tasks = [];
 
-    // Get core tasks from installed bmad directory
-    const coreTasksPath = path.join(this.bmadDir, 'core', 'tasks');
-    if (await fs.pathExists(coreTasksPath)) {
-      const coreTasks = await this.getTasksFromDir(coreTasksPath, 'core');
-      this.tasks.push(...coreTasks);
-    }
-
-    // Get module tasks from installed bmad directory
-    for (const moduleName of selectedModules) {
+    // Use updatedModules which already includes deduplicated 'core' + selectedModules
+    for (const moduleName of this.updatedModules) {
       const tasksPath = path.join(this.bmadDir, moduleName, 'tasks');
 
       if (await fs.pathExists(tasksPath)) {
@@ -341,7 +354,8 @@ class ManifestGenerator {
         const standalone = !!standaloneMatch;
 
         // Build relative path for installation
-        const installPath = moduleName === 'core' ? `bmad/core/tasks/${file}` : `bmad/${moduleName}/tasks/${file}`;
+        const installPath =
+          moduleName === 'core' ? `${this.bmadFolderName}/core/tasks/${file}` : `${this.bmadFolderName}/${moduleName}/tasks/${file}`;
 
         const taskName = file.replace(/\.(xml|md)$/, '');
         tasks.push({
@@ -373,15 +387,8 @@ class ManifestGenerator {
   async collectTools(selectedModules) {
     this.tools = [];
 
-    // Get core tools from installed bmad directory
-    const coreToolsPath = path.join(this.bmadDir, 'core', 'tools');
-    if (await fs.pathExists(coreToolsPath)) {
-      const coreTools = await this.getToolsFromDir(coreToolsPath, 'core');
-      this.tools.push(...coreTools);
-    }
-
-    // Get module tools from installed bmad directory
-    for (const moduleName of selectedModules) {
+    // Use updatedModules which already includes deduplicated 'core' + selectedModules
+    for (const moduleName of this.updatedModules) {
       const toolsPath = path.join(this.bmadDir, moduleName, 'tools');
 
       if (await fs.pathExists(toolsPath)) {
@@ -417,7 +424,8 @@ class ManifestGenerator {
         const standalone = !!standaloneMatch;
 
         // Build relative path for installation
-        const installPath = moduleName === 'core' ? `bmad/core/tools/${file}` : `bmad/${moduleName}/tools/${file}`;
+        const installPath =
+          moduleName === 'core' ? `${this.bmadFolderName}/core/tools/${file}` : `${this.bmadFolderName}/${moduleName}/tools/${file}`;
 
         const toolName = file.replace(/\.(xml|md)$/, '');
         tools.push({
@@ -451,22 +459,26 @@ class ManifestGenerator {
 
     const manifest = {
       installation: {
-        version: '6.0.0-alpha.0',
+        version: packageJson.version,
         installDate: new Date().toISOString(),
         lastUpdated: new Date().toISOString(),
       },
-      modules: this.modules,
+      modules: this.modules, // Include ALL modules (standard and custom)
       ides: this.selectedIdes,
     };
 
-    const yamlStr = yaml.dump(manifest, {
+    // Clean the manifest to remove any non-serializable values
+    const cleanManifest = structuredClone(manifest);
+
+    const yamlStr = yaml.stringify(cleanManifest, {
       indent: 2,
-      lineWidth: -1,
-      noRefs: true,
+      lineWidth: 0,
       sortKeys: false,
     });
 
-    await fs.writeFile(manifestPath, yamlStr);
+    // Ensure POSIX-compliant final newline
+    const content = yamlStr.endsWith('\n') ? yamlStr : yamlStr + '\n';
+    await fs.writeFile(manifestPath, content);
     return manifestPath;
   }
 
@@ -558,24 +570,61 @@ class ManifestGenerator {
    */
   async writeWorkflowManifest(cfgDir) {
     const csvPath = path.join(cfgDir, 'workflow-manifest.csv');
+    const escapeCsv = (value) => `"${String(value ?? '').replaceAll('"', '""')}"`;
+    const parseCsvLine = (line) => {
+      const columns = line.match(/(".*?"|[^",\s]+)(?=\s*,|\s*$)/g) || [];
+      return columns.map((c) => c.replaceAll(/^"|"$/g, ''));
+    };
 
-    // Define expected columns and defaults for schema upgrade
-    const expectedColumns = ['name', 'description', 'module', 'path', 'standalone'];
-    const defaultValues = { standalone: 'false' };
+    // 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) {
+          const parts = parseCsvLine(line);
+          if (parts.length >= 4) {
+            const [name, description, module, workflowPath] = parts;
+            existingEntries.set(`${module}:${name}`, {
+              name,
+              description,
+              module,
+              path: workflowPath,
+            });
+          }
+        }
+      }
+    }
 
-    // Get preserved rows from existing CSV (module is column 2, 0-indexed)
-    const preservedRows = await this.getPreservedCsvRows(csvPath, 2, expectedColumns, defaultValues);
+    // Create CSV header - standalone column removed, everything is canonicalized to 4 columns
+    let csv = 'name,description,module,path\n';
 
-    // Create CSV header with standalone column
-    let csv = 'name,description,module,path,standalone\n';
+    // Combine existing and new workflows
+    const allWorkflows = new Map();
 
-    // Add new rows for updated modules
+    // 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}","${workflow.standalone}"\n`;
+      const key = `${workflow.module}:${workflow.name}`;
+      allWorkflows.set(key, {
+        name: workflow.name,
+        description: workflow.description,
+        module: workflow.module,
+        path: workflow.path,
+      });
     }
 
-    // Add preserved rows for modules we didn't update
-    for (const row of preservedRows) {
+    // Write all workflows
+    for (const [, value] of allWorkflows) {
+      const row = [escapeCsv(value.name), escapeCsv(value.description), escapeCsv(value.module), escapeCsv(value.path)].join(',');
       csv += row + '\n';
     }
 
@@ -590,34 +639,50 @@ class ManifestGenerator {
   async writeAgentManifest(cfgDir) {
     const csvPath = path.join(cfgDir, 'agent-manifest.csv');
 
-    // Define expected columns (no schema changes for agents currently)
-    const expectedColumns = [
-      'name',
-      'displayName',
-      'title',
-      'icon',
-      'role',
-      'identity',
-      'communicationStyle',
-      'principles',
-      'module',
-      'path',
-    ];
-
-    // Get preserved rows from existing CSV (module is column 8, 0-indexed)
-    const preservedRows = await this.getPreservedCsvRows(csvPath, 8, expectedColumns);
+    // 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 new rows for updated modules
+    // 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}"`,
+      );
     }
 
-    // Add preserved rows for modules we didn't update
-    for (const row of preservedRows) {
-      csv += row + '\n';
+    // Write all agents
+    for (const [, value] of allAgents) {
+      csv += value + '\n';
     }
 
     await fs.writeFile(csvPath, csv);
@@ -631,24 +696,47 @@ class ManifestGenerator {
   async writeTaskManifest(cfgDir) {
     const csvPath = path.join(cfgDir, 'task-manifest.csv');
 
-    // Define expected columns and defaults for schema upgrade
-    const expectedColumns = ['name', 'displayName', 'description', 'module', 'path', 'standalone'];
-    const defaultValues = { standalone: 'false' };
-
-    // Get preserved rows from existing CSV (module is column 3, 0-indexed)
-    const preservedRows = await this.getPreservedCsvRows(csvPath, 3, expectedColumns, defaultValues);
+    // 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 new rows for updated modules
+    // 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}"`);
     }
 
-    // Add preserved rows for modules we didn't update
-    for (const row of preservedRows) {
-      csv += row + '\n';
+    // Write all tasks
+    for (const [, value] of allTasks) {
+      csv += value + '\n';
     }
 
     await fs.writeFile(csvPath, csv);
@@ -662,24 +750,47 @@ class ManifestGenerator {
   async writeToolManifest(cfgDir) {
     const csvPath = path.join(cfgDir, 'tool-manifest.csv');
 
-    // Define expected columns and defaults for schema upgrade
-    const expectedColumns = ['name', 'displayName', 'description', 'module', 'path', 'standalone'];
-    const defaultValues = { standalone: 'false' };
-
-    // Get preserved rows from existing CSV (module is column 3, 0-indexed)
-    const preservedRows = await this.getPreservedCsvRows(csvPath, 3, expectedColumns, defaultValues);
+    // 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 new rows for updated modules
+    // 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}"`);
     }
 
-    // Add preserved rows for modules we didn't update
-    for (const row of preservedRows) {
-      csv += row + '\n';
+    // Write all tools
+    for (const [, value] of allTools) {
+      csv += value + '\n';
     }
 
     await fs.writeFile(csvPath, csv);
@@ -709,9 +820,6 @@ class ManifestGenerator {
   async writeFilesManifest(cfgDir) {
     const csvPath = path.join(cfgDir, 'files-manifest.csv');
 
-    // Get preserved rows from existing CSV (module is column 2, 0-indexed)
-    const preservedRows = await this.getPreservedCsvRows(csvPath, 2);
-
     // Create CSV header with hash column
     let csv = 'type,name,module,path,hash\n';
 
@@ -720,13 +828,14 @@ class ManifestGenerator {
     if (this.allInstalledFiles && this.allInstalledFiles.length > 0) {
       // Process all installed files
       for (const filePath of this.allInstalledFiles) {
-        const relativePath = 'bmad' + filePath.replace(this.bmadDir, '').replaceAll('\\', '/');
+        // Store paths relative to bmadDir (no folder prefix)
+        const relativePath = filePath.replace(this.bmadDir, '').replaceAll('\\', '/').replace(/^\//, '');
         const ext = path.extname(filePath).toLowerCase();
         const fileName = path.basename(filePath, ext);
 
-        // Determine module from path
+        // Determine module from path (first directory component)
         const pathParts = relativePath.split('/');
-        const module = pathParts.length > 1 ? pathParts[1] : 'unknown';
+        const module = pathParts.length > 0 ? pathParts[0] : 'unknown';
 
         // Calculate hash
         const hash = await this.calculateFileHash(filePath);
@@ -742,10 +851,13 @@ class ManifestGenerator {
     } else {
       // Fallback: use the collected workflows/agents/tasks
       for (const file of this.files) {
-        const filePath = path.join(this.bmadDir, file.path.replace('bmad/', ''));
+        // Strip the folder prefix if present (for consistency)
+        const relPath = file.path.replace(this.bmadFolderName + '/', '');
+        const filePath = path.join(this.bmadDir, relPath);
         const hash = await this.calculateFileHash(filePath);
         allFiles.push({
           ...file,
+          path: relPath,
           hash: hash,
         });
       }
@@ -758,19 +870,50 @@ class ManifestGenerator {
       return a.name.localeCompare(b.name);
     });
 
-    // Add rows for updated modules
+    // Add all files
     for (const file of allFiles) {
       csv += `"${file.type}","${file.name}","${file.module}","${file.path}","${file.hash}"\n`;
     }
 
-    // Add preserved rows for modules we didn't update
-    for (const row of preservedRows) {
-      csv += row + '\n';
-    }
-
     await fs.writeFile(csvPath, csv);
     return csvPath;
   }
+
+  /**
+   * Scan the bmad directory to find all installed modules
+   * @param {string} bmadDir - Path to bmad directory
+   * @returns {Array} List of module names
+   */
+  async scanInstalledModules(bmadDir) {
+    const modules = [];
+
+    try {
+      const entries = await fs.readdir(bmadDir, { withFileTypes: true });
+
+      for (const entry of entries) {
+        // Skip if not a directory or is a special directory
+        if (!entry.isDirectory() || entry.name.startsWith('.') || entry.name === '_config') {
+          continue;
+        }
+
+        // Check if this looks like a module (has agents, workflows, or tasks directory)
+        const modulePath = path.join(bmadDir, entry.name);
+        const hasAgents = await fs.pathExists(path.join(modulePath, 'agents'));
+        const hasWorkflows = await fs.pathExists(path.join(modulePath, 'workflows'));
+        const hasTasks = await fs.pathExists(path.join(modulePath, 'tasks'));
+        const hasTools = await fs.pathExists(path.join(modulePath, 'tools'));
+
+        // If it has any of these directories, it's likely a module
+        if (hasAgents || hasWorkflows || hasTasks || hasTools) {
+          modules.push(entry.name);
+        }
+      }
+    } catch (error) {
+      console.warn(`Warning: Could not scan for installed modules: ${error.message}`);
+    }
+
+    return modules;
+  }
 }
 
 module.exports = { ManifestGenerator };